Properties haben nach Zuweisung falsche Werte

[BlueStarHH]

Zitat von Dejan Vu:

Das Ungewöhnliche ist wohl das hier:

Delphi-Quellcode:

function TForm1.GetReAdr: TAdresse;
begin
  Adresse.Vorname := 'a';
  Adresse.Name := 'b';
  Result := Adresse;
end;

Die Zuweisung von 'a' und 'b' im 'Getter' der ReAdr.

Man würde die Eigenschaften der Adresse einmalig setzen z.B. per LazyLoad.
Oder man würde gleich eine protected Property aus der Adresse machen.

LazyLoad wird im realen Code verwendet. Fehler tritt trotzdem auf. Auch mit einer protected Property. Das hier ist nun ein komprimierter Code um den Fehler zu zeigen...

[Dejan Vu]

Lazy Load sorgt dafür, das solche Zuweisungen nur einmal durchgeführt werden.

Delphi-Quellcode:

// Also so gehts:
Function TForm1.GetReAdr: TAdresse;
Begin
  If fAddress = Nil Then Begin
    Adresse.Vorname := 'a';
    Adresse.Name := 'b';
    fAddress := Adresse;
  End;
  Result := fAddress;
End;

// Und so auch
Function TForm1.GetReAdr: TAdresse;
Begin
  If not fInitialized Then Begin
    Adresse.Vorname := 'a';
    Adresse.Name := 'b';
    fInitialized := True;
  End;
  Result := Adresse;
End;

Allgemein ist das LazyLoad-Pattern für Properties so:

Delphi-Quellcode:

Function TMyClass.GetProperty : TSomeValue;
Begin
  if fProperty=nil then 
    fProperty := CreateSomeValue;
  result := fProperty;
End;

Damit wird nur beim Zugriff, und dann nur beim ersten, instantiiert. Früher nannte man das 'Fetch on demand'. Heute eben 'lazy load'. Und damit schlägt man dem blöden Compiler ein Schnippchen.

[BlueStarHH]

Wie gesagt LazyLoad wird verwendet (siehe Post #6) und ändert am Problem nichts...

[Dejan Vu]

Zitat von BlueStarHH:

Wie gesagt LazyLoad wird verwendet (siehe Post #6) und ändert am Problem nichts...

Bei mir schon (habs gerade probiert). Es ist ja nichts anderes, als mein 2.Vorschlag. Und ich habe deinen Code aus Post #6 kopiert. Geht. Vielleicht ist dein 'IsInitialized' nicht korrekt.

@Sir Rufo: Nee, oder? Verrückt! Tolle Analyse!

Gut, das ich bei C# bin.

[Sir Rufo]

Unter Win64 ist der Pointer-Reigen auch zu beobachten, allerdings sind die Ergebnisse immer korrekt.

Somit wird unter Win64 wohl der Speicherbereich sofort kopiert und bei Win32 wird sich der Pointer gemerkt und zum Schluss zusammenkopiert (mit dem bekannten Ergebnis).

Nur so eine Vermutung und ich will da jetzt auch nicht zu sehr in die Tiefe gehen

[himitsu]

Kurzfassung: Delphi verwendet hier nur eine Variable, obwohl es zwei verwenden müsste, da erst nach dem zweiten Funktionsaufruf die Strings zusammengemanscht werden.

Eventuell könnten ein paar Klammern hier helfen.

Delphi-Quellcode:

function TForm1.GetDebitorName: string;
begin
  Result := Copy(GetReAdr.Vorname + ' ') + GetReAdr.Name;
end;

[Der schöne Günther]

Hat das mittlerweile jemand in den QC eingetragen? Wenn nicht, würde ich das heute machen...

[Sir Rufo]

Das Problem ist die Referenz-Zählung für die Strings. Bei jeder Zuweisung wird der String an eine andere Speicheradresse geschrieben und die alte Speicheradresse wird als frei markiert.

Es taucht nicht auf, wenn man für die Eigenschaften Name und Vorname einen Getter benutzt

Delphi-Quellcode:

type
  TAdresse = class
  private
    FVorname: string;
    FName: string;
    function GetName: string;
    function GetVorname: string;
  public
    property Vorname: string read GetVorname write FVorname;
    property Name: string read GetName write FName;
  end;

Weiterhin taucht es nicht auf, wenn man die Adresse so zusammensetzt

Delphi-Quellcode:

function TFoo.GetFullName : string;
begin
  Result := GetAdresse.Vorname + GetAdresse.Nachname;
end;

Und wenn man sich mal spasseshalber die Pointer auf die Variablen holt

Delphi-Quellcode:

function TTest.GetFullName : string;
var
  LVorname, LName : PChar;
begin
  LVorname := PChar( GetAdresse.Vorname );
  // jetzt zeigt der Debugger den korrekten Vornamen bei LVorname an
  LName := PChar( GetAdresse.Name );
  // ab jetzt steht in LVorname und LName der gleiche Wert, weil nun die Pointer an die gleiche Stelle zeigen
  Result := GetAdresse.Vorname + GetAdresse.Nachname;
end;

Dieses ist aber eher Zufall, da die beiden Speicherstellen abwechselnd belegt werden, was wir mit folgendem Code überprüfen können

Delphi-Quellcode:

function TTest.GetFullName: string;
var
  LName1, LVorname, LName2 : PChar;
begin
{1}  LName1 := PChar( GetAdresse.Name );
{2}  LVorname := PChar( GetAdresse.Vorname );
{3}  LName2 := PChar( GetAdresse.Name );
end;

Hier die Inhalte jeweils nach der Codezeile

Nr	LName1	LVorname	LName2
{1}	Lustig	-	-
{2}	Lustig	Peter	-
{3}	Peter	Lustig	Lustig

oder wenn man sich die Pointer-Adressen anschaut, dann (Beispielswerte, die ändern sich eh je nach Start)

Nr	LName1	LVorname	LName2
{1}	$420C	-	-
{2}	$420C	$422C	-
{3}	$420C	$422C	$422C

Oder hier einmal schön den Wechselreigen mit den Adressen bei der Zuweisung

Codezeile	+ Adresse	- Adresse
Adresse.Vorname := 'Peter';	A
Adresse.Name := 'Lustig';	B
Zugriff auf Vorname => A
Adresse.Vorname := 'Peter';	C	A
Adresse.Name := 'Lustig';	A	B
Zugriff auf Name => A
Adresse.Vorname := 'Peter';	B	C
Adresse.Name := 'Lustig';	C	A

Der Vollständigkeit halber sei noch erwähnt, dass dieses hier

Delphi-Quellcode:

function TTest.GetFullNameReverse: string;
begin
  Result := GetAdresse.Name + ' ' + GetAdresse.Vorname;
end;

natürlich einwandfrei funktioniert. Warum?

Codezeile	+ Adresse	- Adresse
Adresse.Vorname := 'Peter';	A
Adresse.Name := 'Lustig';	B
Zugriff auf Name => B
Adresse.Vorname := 'Peter';	C	A
Adresse.Name := 'Lustig';	A	B
Zugriff auf Vorname => C
Adresse.Vorname := 'Peter';	B	C
Adresse.Name := 'Lustig';	C	A

(funktioniert aber auch nur, weil der Speicherbereich noch nicht überschrieben wurde)