Operatoren überschreiben

[Matze]

Hallo,

das klingt etwas absurd und ich benötige es auch nicht, aber mich interessiert, ob man in Delphi Operatoren überschreiben kann. Dass ich z.B. sage, das "+" soll andere Operationen ausführen, als es normalerweise der Fall ist.

Geht das mit Delphi?

[Bernhard Geyer]

In Delphi 2006 - Ja. Siehe Videos von Daniel zu BDS 2006

[Matze]

Hallo, stimmt, da geht das, das habe ich gesehen. Also unter Delphi-Versionen kleiner 2006 ist dies gar nicht möglich?

[jim_raynor]

Zitat:

Zitat von Matze

Hallo, stimmt, da geht das, das habe ich gesehen. Also unter Delphi-Versionen kleiner 2006 ist dies gar nicht möglich?

korrekt. Erst ab Delphi 2006

[Matze]

Zitat:

Zitat von jim_raynor

korrekt. Erst ab Delphi 2006

Ok, danke.
Ada, das ja auch auf Pascal basiert, kann das seit 1995, darum habe ich gefragt. ;)

Code:

[b][color=Navy]with[/color][/b] Ada.Integer_Text_IO;

[b][color=green]------------------------------------------------------------------------------
-- PROCEDURE: MultiRationalNumber
-- DESCRIPTION:
--   Main function to add 2 rational numbers
------------------------------------------------------------------------------[/color][/b]
[b][color=Navy]procedure[/color][/b] MultiRationalNumber [b][color=Navy]is[/color][/b]

  [b][color=Navy]type[/color][/b] TRationalNumber [b][color=Navy]is record[/color][/b]
    Numerator: Integer;
    Denominator: Natural;
  [b][color=Navy]end record[/color][/b];
  
[b][color=green]  ----------------------------------------------------------------------------
  -- FUNCTION: "*"
  -- DESCRIPTION:
  --   Addition of 2 rational numbers
  -- PARAMETER:
  --   +Number1: 1st rat. number
  --   +Number2: 2nd rat. number
  -- RETURN:
  --   Number1 * Number 2
  -- NOTES: Result is unabridged
  ----------------------------------------------------------------------------[/color][/b]
  [b][color=Navy]function[/color][/b] "*" (Number1, Number2: TRationalNumber) [b][color=Navy]return[/color][/b] TRationalNumber [b][color=Navy]is[/color][/b]
    Result: TRationalNumber;
  [b][color=Navy]begin[/color][/b]
    Result.Numerator := Number1.Numerator * Number2.Numerator;
    Result.Denominator := Number1.Denominator * Number2.Denominator;
    
    [b][color=Navy]return[/color][/b] Result;
  [b][color=Navy]end[/color][/b] "*";
  
  Rat1, Rat2: TRationalNumber;
  NewRationalNumber: TRationalNumber;
[b][color=Navy]begin[/color][/b]
  Rat1.Numerator := 4;
  Rat1.Denominator := 5;
  
  Rat2.Numerator := 7;
  Rat2.Denominator := 12;
  
  NewRationalNumber := Rat1 * Rat2;
  
  Ada.Integer_Text_IO.Put(NewRationalNumber.Numerator);
  Ada.Integer_Text_IO.Put(NewRationalNumber.Denominator);
[b][color=Navy]end[/color][/b];

[Sharky]

Zitat:

Zitat von Matze

.... ob man in Delphi Operatoren überschreiben kann. ...

Hai ihr,

es passt zwar nicht genau zum Thread :oops:
Aber eine Frage: Kann ich denn auch einen eigenen Operator definieren?

Zum Beispiel:

Code:

var
  a , b , c : boolean;
begin
  a := True;
  b := True
  c := a [b]NAND[/b] b;
end;

[NicoDE]

Zitat:

Zitat von Sharky

Kann ich denn auch einen eigenen Operator definieren?

Da die überschriebenen Operatoren mit vordefinierten Namen angesprochen werden, ist davon auszugehen, dass der Compiler keine anderen kennt (lies: ich denke, nein).

[jbg]

Wenn man eine .NET Anwendung schreibt, dann kann man Operatoren auch schon seit Delphi 8 überschreiben.

[Chewie]

Oder FreePascal benutzen, da geht das auch schon länger ;)

[LarsMiddendorf]

Man kann auch schon ab Delphi4 (glaube ich) einen eigenen Variant Type definierten und hat dafür dann eine Klasse mit den ganzen Operatoren registrieren. In der Hilfe ist ein Beispiel wie man damit eine Klasse für komplexe Zahlen macht.

[Lemmy1]

Zitat:

Zitat von Sharky

Zitat:

Zitat von Matze

.... ob man in Delphi Operatoren überschreiben kann. ...

Hai ihr,

es passt zwar nicht genau zum Thread :oops:
Aber eine Frage: Kann ich denn auch einen eigenen Operator definieren?

Hab mal ein Interview mit Danny Thorpe (glaub ich) gehört, wo er explizit sagte, dass das nicht geht. Dann müsste nämlich bereits der Parser Deine Operatoren kennen, was eine unschwer größere Aufgabe wäre.

[Lemmy1]

Korrektur: Ich meine nicht den Parser, sondern genauer den Scanner (das ist die erste Stufe eines Compilers)

[rayman]

Hallo.

Welche Operatoren kann ich denn alle überschreiben?
Ich kenne jetzt aus dem Video nur die Rechenoperatoren mit Namen:

add, subtract, multiply, divide, implicit, greaterThan, lessThen, greaterThanOrEqual, lessThanOrEqual und equal.

Aber was ist mit den anderen?
Es gibt doch mindestens noch or und and, die auch einen Namen haben müssten. Dann kenn ich noch in für Mengen. die ungleich Relation (<>) und viele andere (div, mod, shl und shr, xor, is,...).

Wo kann ich eine Liste mit den ganzen Namen dafür kriegen?

[3_of_8]

Vllt hilft da die Code-Vervollständigung? (Strg+Space wenn du "class operator" schon geschrieben hast)

[Meflin]

Zitat:

Implicit
Konvertierung
Implicit(a : Typ): Ergebnistyp;
Implizite Typumwandlung

Explicit
Konvertierung
Explicit(a: Typ): Ergebnistyp;
Explizite Typumwandlung

Negative
Unär
Negative(a: Typ): Ergebnistyp;
-

Positive
Unär
Positive(a: Typ): Ergebnistyp;
+

Inc
Unär
Inc(a: Typ): Ergebnistyp;
Inc

Dec
Unär
Dec(a: Typ): Ergebnistyp
Dec

LogicalNot
Unär
LogicalNot(a: Typ): Ergebnistyp;
not

BitwiseNot
Unär
BitwiseNot(a: Typ): Ergebnistyp;
not

Trunc
Unär
Trunc(a: Typ): Ergebnistyp;
Trunc

Round
Unär
Round(a: Typ): Ergebnistyp;
Round

Equal
Vergleich
Equal(a: Typ; b: Typ): Boolean;
=

NotEqual
Vergleich
NotEqual(a: Typ; b: Typ): Boolean;
<>

GreaterThan
Vergleich
GreaterThan(a: Typ; b: type) Boolean;
>

GreaterThanOrEqual
Vergleich
GreaterThanOrEqual(a: Typ; b: Typ): Ergebnistyp;
>=

LessThan
Vergleich
LessThan(a: Typ; b: Typ): Ergebnistyp;
<

LessThanOrEqual
Vergleich
LessThanOrEqual(a: Typ; b: Typ): Ergebnistyp;
<=

Add
Binär
Add(a: Typ; b: Typ): Ergebnistyp;
+

Subtract
Binär
Subtract(a: Typ; b: Typ): Ergebnistyp;
-

Multiply
Binär
Multiply(a: Typ; b: Typ): Ergebnistyp;
*

Divide
Binär
Divide(a: Typ; b: Typ): Ergebnistyp;
/

IntDivide
Binär
IntDivide(a: Typ; b: Typ): Ergebnistyp;
div

Modulus
Binär
Modulus(a: Typ; b: Typ): Ergebnistyp;
mod

ShiftLeft
Binär
ShiftLeft(a: Typ; b: Typ): Ergebnistyp;
shl

ShiftRight
Binär
ShiftRight(a: Typ; b: Typ): Ergebnistyp;
shr

LogicalAnd
Binär
LogicalAnd(a: Typ; b: Typ): Ergebnistyp;
and

LogicalOr
Binär
LogicalOr(a: Typ; b: Typ): Ergebnistyp;
or

LogicalXor
Binär
LogicalXor(a: Typ; b: Typ): Ergebnistyp;
xor

BitwiseAnd
Binär
BitwiseAnd(a: Typ; b: Typ): Ergebnistyp;
and

BitwiseOr
Binär
BitwiseOr(a: Typ; b: Typ): Ergebnistyp;
or

BitwiseXor
Binär
BitwiseXor(a: Typ; b: Typ): Ergebnistyp;
xor

siehe die Hilfe unter ms-help://borland.bds4/bds4ref/html/OperatorOverloads.htm#FirstSubtopic1Title

[rayman]

sehr super :thumb: danke.

[3_of_8]

Ein Operator fehlt... Ich gehe mal davon aus, dass man @ nicht überschreiben kann?

[Dax]

Den Adressoperator überschreiben :lol: Guter Witz :)

[OregonGhost]

Zitat:

Zitat von Dax

Den Adressoperator überschreiben :lol: Guter Witz :)

Du hast dich noch nie mit C++ beschäftigt, oder? Da geht das nämlich - insofern ist die Frage keineswegs ein Witz :)

[mkinzler]

Und wass soll es bringen den @-Operator zu überladen?

[OregonGhost]

Das typische Einsatzgebiet dafür sind, soweit ich mich da erinnere, Smartpointer. In C++ können Objekte ja einfach auf dem Stack deklariert werden und werden somit automatisch zerstört, wenn sie den Gültigkeitsbereich verlassen. Das Verhalten nutzt man aus, um damit Smartpointer, also intelligente Zeiger, auf Objekte zu implementieren, beispielsweise COM-Objekte. Dabei werden die Operatoren -> und & überschrieben, damit sie die Adresse bzw. die Elemente des COM-Objekts und nicht die der Smartpointer-Klasse zurückgeben. Ich finde das ganze zwar etwas pervers, aber möglich ist es und wirklich dumm auch nicht, ob es in Delphi dafür eine Notwendigkeit gibt, ist eine ganz andere Geschichte :)

[himitsu]

mal 'ne frage, wozu ist eigentlich der Positive Operator?

OK, bei Negative (-x) wird ja der Wert (Vorzeichen) geändert, aber bei Positive (+x) passiert doch nichts :gruebel:

[grenzgaenger]

sagen wir mal so, die operatoren auf records kann man seit D2006 überschreiben, die auf objekte geht schon früher :-)

schöne grüsse
GG