[XE3] Operator Overloading, Verhalten?

[JamesTKirk]

Zitat von 4dk2:

Das Delphi das seit Delphi2006 schon kann war mir neu.

Und FPC kann das schon viel länger

Zitat von 4dk2:

Delphi-Quellcode:

class operator TVarX.implicit(const z: integer): TVarX;
begin
  result.Value := z;
end;

Das hier ist falsch. Ein Operator in Delphi ist implizit immer eine statische Funktion. Das heißt es gibt kein Self und du kannst damit auch nicht davon ausgehen, dass Felder irgendwie übernommen werden. Hier schlägt dann nämlich die Freiheit des Compilers zu, wie er das Result bzw. die Variable, auf die das Result von Implicit() zugewiesen wird, an die Implicit-Funktion übergeben wird (entweder ein Pointer auf eine bisherige Variable, Pointer auf eine temporäre Variable, die dann zu der anderen zugewiesen wird, etc.). Wie himitsu also bereits gesagt hat, musst du Result immer vollends initialisieren.

Ich hab deinen Code auch mal unter FPC ausprobiert (wo das selbe Ergebnis rauskommt) und wenn man sich den generierten Assemblercode anschaut, so sieht man, dass im Fall von localVar1 die Adresse dieser Variablen selbst an Implicit() übergeben wird, während in den beiden anderen Fällen eine lokale temporäre Variable verwendet und diese anschließend an globalVar1 und FormVar1 kopiert wird.

Gruß,
Sven

[4dk2]

OK, also ich denke wir können das damit abschließen,
ABER seht ihr da irgendeine alternative Möglichkeit mit, (nennen wir es mal Objekte) mit Objekten rechnen Operationen durchzuführen, und im Hintergrund
jedem Objekt eine Referenzen auf andere Objekte zu halten?
Ohne z.b. variable.wert!

Bisher hab ich das so ähnlich gemacht:

Delphi-Quellcode:

unit Unit1;

interface

uses
  Winapi.Windows, Winapi.Messages, System.SysUtils, System.Variants, System.Classes, Vcl.Graphics,
  Vcl.Controls, Vcl.Forms, Vcl.Dialogs, Vcl.StdCtrls, System.Generics.Collections;

type
  TVarIntX = record
    ValuePtr: PInteger;
    Objekt: TObject;
  end;

  TVarInt_List = TList<TVarIntX>;

  TForm1 = class(TForm)
    procedure FormCreate(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
  private
    TestInt: integer;
    ListTest: TVarInt_List;
    procedure Test;
    function FindObjekt(varptr: PInteger): TObject;
    { Private-Deklarationen }
  public
    { Public-Deklarationen }
  end;

var
  Form1: TForm1;

implementation

{$R *.dfm}

function TForm1.FindObjekt(varptr: PInteger): TObject;
var i:integer;
    v:TVarIntX;
begin
  result:=nil;
  for I := 0 to ListTest.Count-1 do
  begin
    v:=ListTest[i];
    if v.ValuePtr=varptr then
    begin
      result:=v.Objekt;
      break;
    end;
  end;
end;

procedure TForm1.Test;
var
  v: TVarIntX;
  o:Tobject;
begin
  // initialisieren..
  v.ValuePtr := addr(TestInt);
  v.Objekt := self;
  ListTest.Add(v);
  // ------------------

  TestInt := 100;
  TestInt := TestInt*2;
  TestInt := TestInt+200;

  //jetzt zugeordnetes objekt holen für irgendwas...
  o:=FindObjekt(addr(TestInt));
  if Assigned(o) and (o is TForm) then
    (o as TForm).Caption:='test';


end;

procedure TForm1.FormCreate(Sender: TObject);
begin
  ListTest := TList<TVarIntX>.create();
  Test();
end;

procedure TForm1.FormDestroy(Sender: TObject);
begin
  ListTest.Free;
end;

end.

[Uwe Raabe]

Entweder ist dein Beispiel schlecht konstruiert oder du siehst den Wald vor lauter Bäumen nicht.

Warum der Umweg über den ValuePtr? Sag doch einfach

Delphi-Quellcode:

type
  TVarIntX = record
    Value: Integer;
    Objekt: TObject;
  end;

und in den Berechnungen nimmst du gleich v.Value anstatt TestInt .

[4dk2]

Zitat von Uwe Raabe:

Entweder ist dein Beispiel schlecht konstruiert oder du siehst den Wald vor lauter Bäumen nicht.

Ist jetzt nicht das optimale Beispiel

Zitat:

und in den Berechnungen nimmst du gleich v.Value ...

Das will ich ja vermeiden.

In meinem Fall geht es um Mathematische Berechnungen mit Hunderten von diversen Variablen, die unterschiedlichen Objekten zugeordnet sind (teilweise auch Datenbanken).
bei allen Variablen ein .value anzuhängen macht da keinen Sinn.

Bisher gibt es vorm berechnen ein Load() und nach dem berechnen ein Save(), die jeweils ein paar seiten umfassen.
Ich dachte mir, dass man das Load und Save evtl. vereinfachen könnte.
Klar einmal Initialisieren bleibt, aber Load und Save könnten dann zwei schleifen sein.

Delphi-Quellcode:

for i := 0 to ListX.count-1 do
  ListX[i].Save() //Load()

[Uwe Raabe]

Zitat von 4dk2:

Zitat:

und in den Berechnungen nimmst du gleich v.Value ...

Das will ich ja vermeiden.

In meinem Fall geht es um Mathematische Berechnungen mit Hunderten von diversen Variablen, die unterschiedlichen Objekten zugeordnet sind (teilweise auch Datenbanken).
bei allen Variablen ein .value anzuhängen macht da keinen Sinn.

Macht keinen Sinn oder ist lästig? Das wäre immerhin genau das, was ich dir empfehlen würde - natürlich unter dem Vorbehalt, daß ich den realen Anwendungsfall eben nicht kenne.

[4dk2]

ne macht keinen sinn.
Hatte das vor einiger Zeit mal bei einem Block getestet.
Vor lauter .value's sieht man dann den Wald nicht mehr

Das mit der Variable-Pointer + Object "Version", hatte ich damals auch schon im Hinterkopf,
aber nicht umgesetzt.
Und dann vor ein paar Tagen das mit den Operator Overload gelesen.

[himitsu]

Es ist vielleicht "lästig, macht aber dennoch Sinn.

Grade beim wilden Rumgepointere können böse Fehler entstehen und das Debuggen macht es auch nicht besser.