operator overloading

[bernau]

Ich experimentiere grade mit operator overloading.

Folgenden record habe ich:

Delphi-Quellcode:

  TTestRec = record
    private
      fValue:byte;
      fstatus:integer;
    public
      class operator implicit(const aValue: TTestRec): Byte; inline;
      class operator implicit(const aValue: Byte): TTestRec; inline;
      procedure SetStatus(aStatus:integer);
      function GetStatus:Integer;
    end;

implementation

{ TTestRec }

class operator TTestRec.implicit(const aValue: TTestRec): Byte;
begin
  result := aValue.fValue;
end;

class operator TTestRec.implicit(const aValue: Byte): TTestRec;
begin
  result.fValue := aValue;
end;

procedure TTestRec.setStatus(aStatus: integer);
begin
  fstatus := aStatus;
end;

function TTestRec.GetStatus: Integer;
begin
  result := fstatus
end;

Hautpsächlich wird fValue verwendet um Daten zu halten und Berechnungen durchzuführen. operator overloading ist dafür eine schöne Sache. So kann ich mit ganz normalen Operatoren lesbaren Code erzeugen.

Status wird nur ein mal gesetzt. Dann sollte der Wert immer gleich bleiben.

Leider wird bei der Wert von fStatus immer wieder ungültig, wenn ich fValue über den class operator setze.

Delphi-Quellcode:

var 
  a : TTestRec  
begin
  a := 3; // aValue ist nun 3, fStatus ist noch undefiniert.
  a.SetStatus(10); // aValue ist nun 3, fStatus ist nun 10;
  a := 5; // aValue ist nun 5, fStatus hat einen zufälligen Wert.
end;

Muss ich mit einem Class Operator immer alle Variablen des Records setzen?

Gibt es eine Möglichkeit, bei dem der Wert von fStatus unverändert und somit gültig bleibt?

[himitsu]

Geh davon aus, dass Result deiner Methoden/Operatoran IMMER einen neuen Record erzeugt und damit die Varaible überschreibt.

Was du da nicht setzt ist potentiell nicht initialisiert und somit zufällig.

[bernau]

Ich habe es mir schon gedacht. Dann muss ich wohl auf operatoren in einem record verzichten.

[himitsu]

Wenn nur Teile geändert werden sollen, dann sind Zuweisungen/Umwandlungen (Conversion) halt nicht möglich, da sie eben komplett umwandeln/überschreiben.
Aber binäre Operationen (Binary) wären möglich, da dort der alte Wert mit dem Neuen "verrechnet" wird. (z.B. Addition oder Multiplikation)