Mit den Klassenoperatoren kann man den Record die selben „mathematischen“ Operatoren beibringen, welche man z.B. von den Integern kennt.
Gut nutzbar für BigNumber-, Vector-, Verschlüsselungs- oder Hash-Typen.

type
  TOperatorDemo = record
  private
    FData: Integer;
  public
    class operator Implicit(A: Integer): TOperatorDemo;
    class operator Explicit(A: TOperatorDemo): Integer;
    class operator Add(A, B: TOperatorDemo): TOperatorDemo;

    function ToString: string;
  end;

var A: TOperatorDemo;

A := 120;    // Implicit
A := A + 3;  // Add
ShowMessage(IntToStr(Integer(A)));  // Explicit
ShowMessage(A.ToString);            // Method

Mögliche Operatoren:

Operator           Konvention  Aufruf            Bezeichnung

Explicit           Convert     R := TypeR(A);    Cast
Implicit           Convert     R := A;           AutoCast

Positive           Unary       +A                Positiv
Negative           Unary       -A                Negieren
BitwiseNot         Unary       {error}           Bitweises Nicht (nicht verwendbar)
LogicalNot         Unary       not A             Logisches Nicht

Inc                Unary       Inc(A);           Inkrementieren
Dec                Unary       Dec(A);           Dekrementieren
Trunc              Unary       Trunc(A)          Abschneiden
Round              Unary       Round(A)          Runden

Add                Binary      A + B             Addition
Subtract           Binary      A - B             Subtraktion
Multiply           Binary      A * B             Multiplikation
Divide             Binary      A / B             Division
IntDivide          Binary      A div B           Ganzzahl-Division
Modulus            Binary      A mod B           Modulo-Operation (Rest)

BitwiseAnd         Binary      A and B           Bitweises Und
BitwiseOr          Binary      A or  B           Bitweises Oder
BitwiseXor         Binary      A xor B           Bitweises Exklusiv-Oder
LogicalAnd         Binary      A and B           Logisches Und
LogicalOr          Binary      A or  B           Logisches Oder
LogicalXor         Binary      A xor B           Logisches Exklusiv-Oder
LeftShift          Binary      A shl B           Links-Verschiebung
RightShift         Binary      A shr B           Rechts-Verschiebung

Equal              Compare     A =  B            Gleichheits-Operator
NotEqual           Compare     A <> B            Ungleichheits-Operator
GreaterThan        Compare     A >  B            Größer-Als-Operator
GreaterThanOrEqual Compare     A >= B            Größer-Als-Oder-Gleich-Operator
LessThan           Compare     A <  B            Kleiner-Als-Operator
LessThanOrEqual    Compare     A <= B            Kleiner-Als-Oder-Gleich-Operator

Include            Unary       Include(A, B);
Exclude            Unary       Include(A, B);
In                 Compare     A in B

OnesComplement     Compare     (siehe Nachwort)
True               UnaComp     if A then         Boolesche Auswertung
False              UnaComp     (siehe Nachwort)  Boolesche Auswertung (not)

Konventionen (Deklarationen der Operatoren):

{Convert} class operator MyOP(A: TypeA): TypeB;                   // Konvertierung
{Unary}   class operator MyOP(A: TypeA): TypeAorB;                // unäre Operation (1)
{Binary}  class operator MyOP(A: TypeA; B: TypeAorB): TypeABorC;  // binäre Operation (2)
{Compare} class operator MyOP(A: TypeA; B: TypeAorB): Boolean;    // Vergleichen
{UnaComp} class operator MyOP(A: TypeA): Boolean;                 // Boolesche Auswertung

Die Unterscheidung zwischen bitweisen und logischen Operatoren hat in Delphi keine Bedeutung, denn hier wird das nicht direkt per Operator unterschieden, sondern richtet sich nach den Typen.
Boolesche Typen werden im Allgemeinen logisch behandelt und ordinale Typen vorzugsweise binär.
Im C++Builder und .NET sieht das anders aus, denn dort gibt es die entsprechenden Operatoren, wie z.B. & und &&.

Da Delphi keine Unterscheidung zwischen logischen und bitweisen Operatoren macht, wird beim Aufruf von Not, And, Or und Xor zuerst nach den Logical-Methoden gesucht und dieses verwendet.

if not A then wird nicht nach A.False übersetzt, sondern A.LogicalNot.True.
OnesComplement ist im Delphi ebenfalls nicht nutzbar.
Und dem Error-Insight sind die unären Vergleichoperatoren (ala True) scheinbar nicht bekannt, drum meckert das gern rum.

 

(noch nicht abgestimmt)  

Loading...