Hallo,

das Thema gibt es sicher schon, ich konnte es aber nicht finden. Irgendwo hab ich hier gesehen, wie man eine Klasse für Vektorrechnung so umsetzt, dass Operatoren wie +/-/x/... richtig interpretiert werden, sodass man nicht schreiben muss: cVektor := vadd(aVector, bVector) sondern einfach cVektor = aVektor + bVektor und die Funktion rechnet dann entsprechend.

sorry, wenn es jetzt doch leicht zu finden ist und danke
gruß
cltom

Das geht nur mit Records, nicht mit Klassen, und man nennt das Überladene Operatoren. In dem Artikel steht eigentlich alles drin, was man braucht.

Eine Beispiel-Implementierung um einDreieck um einen Punkt zu drehen; die Verwendung:

zusammenfalten · markieren

Delphi-Quellcode:

var
  Alpha: Extended;
  O, X, Y, Z: TVector2D;
  U, V, W: TPoint;
begin
  Alpha := 0; // Drehwinkel
  O := TVector2D.New(200, 200); // Ortsvektor zum Drehpunkt
  X := TVector2D.New(-80, 0); // Dreieckspunkte relativ zum Drehpunkt
  Y := TVector2D.New(0, -80);
  Z := TVector2D.New(80, 0);

  { Das Dreieck erst drehen, dann um den Ortsvektor verschieben; denn:
  O + X.Rotated(Alpha)  <>  (O + X).Rotated(Alpha). }
  U := O + X.Rotated(Alpha);
  V := O + Y.Rotated(Alpha);
  W := O + Z.Rotated(Alpha);

  Image1.Canvas.Polygon([U, V, W]);
end;

Ich hatte sowas schon mal probeweise für zweidimensionale Vektoren implementiert, das aber später aus Performancegründen nicht weiter verfolgt. Im 3D-Bereich gibt es dann allerdings zwei Arten der Multiplikation zweier Vektoren. Leider geht das Overloading der Operatoren nicht so weit, daß man dort noch nach dem Ergebnistyp unterscheidet. In dem Fall würde das Kreuzprodukt dann wohl aus der Semantik rausfallen.

zusammenfalten · markieren

Delphi-Quellcode:

const
  NativeFormat: TFormatSettings = (DecimalSeparator: '.');

type
  TVektor = record
    X, Y: Extended;
    class operator Add(A, B: TVektor): TVektor;
    class operator Divide(A: TVektor; B: Extended): TVektor;
    class operator Equal(A, B: TVektor): Boolean;
    class operator Explicit(A: TVektor): string;
    class operator Implicit(A: TVektor): string;
    class operator Multiply(A: Extended; B: TVektor): TVektor;
    class operator Multiply(A: TVektor; B: Extended): TVektor;
    class operator Multiply(A: TVektor; B: TVektor): Extended;
    class operator Negative(A: TVektor): TVektor;
    class operator NotEqual(A, B: TVektor): Boolean;
    class operator Positive(A: TVektor): TVektor;
    class operator Subtract(A, B: TVektor): TVektor;
  end;

class operator TVektor.Add(A, B: TVektor): TVektor;
begin
  result.X := A.X + B.X;
  result.Y := A.Y + B.Y;
end;

class operator TVektor.Divide(A: TVektor; B: Extended): TVektor;
begin
  result.X := A.X / B;
  result.Y := A.Y / B;
end;

class operator TVektor.Equal(A, B: TVektor): Boolean;
begin
  result := SameValue(A.X, B.X) and SameValue(A.Y, B.Y);
end;

class operator TVektor.Explicit(A: TVektor): string;
begin
  result := Format('(%1.3f, %1.3f)', [A.X, A.Y], NativeFormat);
end;

class operator TVektor.Implicit(A: TVektor): string;
begin
  result := string(A);
end;

class operator TVektor.Multiply(A: Extended; B: TVektor): TVektor;
begin
  result.X := A * B.X;
  result.Y := A * B.Y;
end;

class operator TVektor.Multiply(A: TVektor; B: Extended): TVektor;
begin
  result.X := A.X * B;
  result.Y := A.Y * B;
end;

class operator TVektor.Multiply(A, B: TVektor): Extended;
begin
  result := A.X * B.X + A.Y * B.Y;
end;

class operator TVektor.Negative(A: TVektor): TVektor;
begin
  result.X := -A.X;
  result.Y := -A.Y;
end;

class operator TVektor.NotEqual(A, B: TVektor): Boolean;
begin
  result := not SameValue(A, B);
end;

class operator TVektor.Positive(A: TVektor): TVektor;
begin
  result := A;
end;

class operator TVektor.Subtract(A, B: TVektor): TVektor;
begin
  result.X := A.X - B.X;
  result.Y := A.Y - B.Y;
end;

Zitat von Uwe Raabe:

Im 3D-Bereich gibt es dann allerdings zwei Arten der Multiplikation zweier Vektoren.

Zusätzlich zu Kreuzprodukt und Skalarprodukt gibt es noch die Elemente-weise Multiplikation, die ist je nach Anwendung auch nicht so uninteressant.

Wie sieht es eigentlich mit dem "Nextgen"-Compiler aus? Da müsste doch für Klassen mittlerweile volle Operator-Überladung funktionieren, oder?

Zitat von Der schöne Günther:

Wie sieht es eigentlich mit dem "Nextgen"-Compiler aus? Da müsste doch für Klassen mittlerweile volle Operator-Überladung funktionieren, oder?

Was bringt dich zu der Annahme?

Zitat von Der schöne Günther:

Wie sieht es eigentlich mit dem "Nextgen"-Compiler aus? Da müsste doch für Klassen mittlerweile volle Operator-Überladung funktionieren, oder?

Theoretisch hätte es jetzt auch schon für Interfaces gehen können. Und ja, beim ARC (NextGen) könnte es funktionieren,
wenn die endlich mal meine Wünsche implementiert hätten, die seit Jahren im QC rumgammeln.

Der Grund, warum es bei Klassen nicht geht/ging, liegt darin begründet, daß dort keine automatische Speicherverwaltung existiert.

markieren

Delphi-Quellcode:

x := a * b + c;
// oder
x := a + b + c;
// [add] und selbst das einfache Nächste geht nicht
x := a + b;

Hier würden ja temporäre Variablen/Instanzen erstellt.
- das Ergebnis von a*b und a+b
- und das Ergebnis von t+c
Aber keiner fühlt sich verantwortlich diese Instanzen freizugeben.


Und es gibt noch ein paar Problemchen, denn es gibt kein Copy-Event, auf welches man per Klassenoperator reagieren kann.
Bei X := Y; kann man mit Klassen und vorallem ohne Referenzzählung nichts richtig behandeln.

Ich hatte mal versucht Interfaces in den Operator-Record zu packen, aber das war eine Heiden Arbeit und so weit ich mich erinnere, gab es dennoch ein paar Problemchen. (wofür ich gerne das Copy-Event haben wollte)
[add] http://www.delphipraxis.net/128555-i...athlib%5D.html