Das geht mit einem anderen Trick, Überladene Funktionen:
Code: Alles auswählen
// Integer überladung
function Divide(const a, b: Integer): Integer;overload;
begin
Result := A div B;
end;
// Float überladung
function Divide(const a, b: Double): Double;overload;
begin
Result := a/b;
end;
class operator TVector./(const lhs, rhs: TSelfType): TSelfType;
var
i: Integer;
begin
for i:=0 to Dim-1 do
Result.Fields[i] := Divide(lhs.Fields[i], rhs.Fields[i]);
end;
Jetzt sucht der Compiler beim Divide das aus was am besten zu dem typen passt, bei Integer typen die Integer variante mit div, bei float typen die double variante mit /.
Mit einem weiteren neuen Feature aus Trunk kann man das sogar noch weiter generalisieren:
Code: Alles auswählen
// Ganz oben:
{$ModeSwitch implicitfunctionspecialization}
// ,,,
// Spezialüberladung für Integer
function Divide(const a, b: Integer): Integer;overload;
begin
Result := A div B;
end;
// Generische Überladung für alle anderen typen
generic function Divide<T>(const a, b: T): T;overload;
begin
Result := a/b;
end;
class operator TVector./(const lhs, rhs: TSelfType): TSelfType;
var
i: Integer;
begin
for i:=0 to Dim-1 do
Result.Fields[i] := Divide(lhs.Fields[i], rhs.Fields[i]);
end;
Jetzt läuft das so ab, das der Compiler nachschaut ob es für den typen einen spezialfall für Dividie gibt (also hier nur für Integer), und für alle anderen typen wird dann stattdessen die Generische Variante verwendet.
Damit funktioniert das jetzt mit allen typen die / überladen, plus integer. Du könntest jetzt z.B. Vectoren von Vectoren bauen, da die ja / überladen wird dann der korrekte Divide aufruf genutzt (der intern dann den Divide von dem untertypen aufruft)