Free bei 2 Objekten mit derselben Referenz -> Ungültige Zeigeroperation

[enigma]

Hallo zusammen,

ich brauche wg. Typumwandlung ( list := TObjectList<TDN>(AObject) )
2 Objekte (also list u. AObject), die ich manuell freigeben muss.

Meine Frage (s. Quellcode):
gibt FreeAndNil(obj1) auch obj2 frei u. wenn ja, wie kann ich prüfen, ob auch
der Inhalt von obj2 aus Speicher freigegeben ist?
Und weshalb kann ich obj1 mehrfach freigeben u. obj2 nicht mehr?
Meine Idee ist:
Sowohl den Speicher von obj1 u. obj2 freigeben u. beide auf nil setzen.

Delphi-Quellcode:

procedure testFreeAndNil;
var
  obj1, obj2: TestKlasse;
begin
  obj1 := TestKlasse.Create;
  obj2 := obj1;

  FreeAndNil(obj1);
  obj1.Free;   {klappt auch nach obigem FreeAndNil(obj1) }
//  obj2.Free; {falls nicht auskommentiert: Ungültige Zeigeroperation}

end;

[Uwe Raabe]

obj1 und obj2 sind Instanzvariablen, das heißt, sie zeigen auf die Instanz eines Objekts oder sind nil. Selbst wenn obj 1 und obj2 auf dieselbe Instanz zeigen, wissen beide Variablen nichts voneinander. Mann kann also einfach eine oder beide auf nil setzen ohne daß sich die beiden stören. Die Objekt-Instanz bleibt davon ebenfalls unbeeinflusst.

Wenn diese Variable nicht nil ist, gibt FreeAndNil nun das Objekt frei, auf das die übergebene Variable zeigt, und setzt die Variable auf nil. Die andere Variable zeigt dann immer noch auf die Objekt-Instanz, die aber nun schon freigegeben ist - die Variable zeigt also sozusagen auf einen ungültigen Speicherbereich. Ein erneutes Freigeben führt dann zu einem Fehler.

[enigma]

Danke für die Antwort,

verstehe ich richtig:
Gebe ich obj1 frei, dann ist der Speicherbereich, auf den beide zeigen, ungültig?
Und wie kann ich dies für obj2 prüfen?
(s.Quellcode: obj2.ClassName wird noch ausgegeben, obj1.ClassName führt zu Fehler).

Und weshalb kann ich mehrfach hintereinander obj1.Free freigeben
u. obj2.Free kann nach obj1.Free nicht mehr freigegeben werden?

  ShowMessage('obj2.ClassName = ' + obj2.ClassName ); Danke für eine Antwort

[enigma]

Hier noch ein Beispiel,
dass der gemeinsame Speicherbereich nicht für obj1 u. obj2 freigegeben ist:

Delphi-Quellcode:

procedure testFreeAndNil;
var
  Temp: TObject;
  obj1, obj2: TestKlasse;
begin
  obj1 := TestKlasse.Create;
  obj1.n := 11;
  obj2 := obj1;


  FreeAndNil(obj1);
  ShowMessage( 
           //'obj1.n = ' + IntToStr(obj1.n) + #13+        {würde zu Zugriffsverletzung führen}
             'obj2.n = ' + IntToStr(obj2.n) + #13+        {Ausgabe: n = 11 !}
           //'obj1.ClassName = ' + obj1.ClassName + #13+  {würde zu Zugriffsverletzung führen}
              'obj2.ClassName = ' + obj2.ClassName );     {klappt}


end;

[SProske]

Zitat von enigma:

Hier noch ein Beispiel,
dass der gemeinsame Speicherbereich nicht für obj1 u. obj2 freigegeben ist:

Delphi-Quellcode:

procedure testFreeAndNil;
var
  Temp: TObject;
  obj1, obj2: TestKlasse;
begin
  obj1 := TestKlasse.Create;
  obj1.n := 11;
  obj2 := obj1;


  FreeAndNil(obj1);
  ShowMessage( 
           //'obj1.n = ' + IntToStr(obj1.n) + #13+        {würde zu Zugriffsverletzung führen}
             'obj2.n = ' + IntToStr(obj2.n) + #13+        {Ausgabe: n = 11 !}
           //'obj1.ClassName = ' + obj1.ClassName + #13+  {würde zu Zugriffsverletzung führen}
              'obj2.ClassName = ' + obj2.ClassName );     {klappt}


end;

obj1 ist durch freeandnil explizit auf nil gesetzt, deswegen knallt es beim Zugriff auf .n. Obj2 ist nicht auf nil gesetzt und der Speicherbereich wurde zufällig noch nicht überschrieben, deswegen klappt der Zugriff noch - das ist aber nich garantiert.

Delphi-Quellcode:

obj1 := TestKlasse.Create;
obj1.n := 11;
obj1.free;
ShowMessage(IntToStr(obj1.n));

Läuft so gut wie immer durch
Ich erinnere mich da an einen Beitrag auf den Delphitagen zu FastMM wo es erstaunlich schwierig war, hier tatsächlich eine Zuggriffsverletzung zu erhalten

[Uwe Raabe]

Zitat von enigma:

Hier noch ein Beispiel,
dass der gemeinsame Speicherbereich nicht für obj1 u. obj2 freigegeben ist:

Freigegeben heißt ja nicht, daß da zwingend was anderes drin steht als vorher. Man darf das halt nur nicht voraussetzen. Mach mal zwischen dem FreeAndNil und dem Zugriff auf obj2.n noch ein paar Create und Free. Irgendwann wird es nicht mehr 11 zurückgeben.

ClassName ist als class function wieder etwas anderes, da es nicht von einer Objekt-Instanz abhängig ist. Man kann ja auch TestKlasse.ClassName aufrufen.

[enigma]

Also ist durch FreeAndNil(obj1) der Speicher zwar freigegeben,
aber noch nicht neu belegt?
Und weshalb kann ich den Speicher über
obj1.Free mehrfach freigeben, aber nicht über obj2.Free?

Delphi-Quellcode:

procedure testFreeAndNil;
var
  obj1, obj2: TestKlasse;
begin
  obj1 := TestKlasse.Create;
  obj2 := obj1;

  FreeAndNil(obj1);
  obj1.Free; {klappt auch nach obigem FreeAndNil(obj1) }
// obj2.Free; {falls nicht auskommentiert: Ungültige Zeigeroperation}

end;

[Olli73]

Zitat von enigma:

Also ist durch FreeAndNil(obj1) der Speicher zwar freigegeben,
aber noch nicht neu belegt?

Ja.

Zitat von enigma:

Und weshalb kann ich den Speicher über
obj1.Free mehrfach freigeben, aber nicht über obj2.Free?

Weil Obj1 auf nil zeigt und Free dadurch gar nix macht. Obj2 zeigt auf den Speicher, wo früher mal das Objekt war und free "knallt" dann.

[himitsu]

Zitat von enigma:

Und weshalb kann ich den Speicher über
obj1.Free mehrfach freigeben, aber nicht über obj2.Free?

Nein.

FreeAndNil setzt auch due Variable auf NIL und Free/FreeAndNil machen nichts mehr wenn die Variable schon NIL ist.

Delphi-Quellcode:

obj := TTestKlasse.Create;
obj.Free;
obj.Free;  // peng

obj := TTestKlasse.Create;
obj.Free;
obj := nil;
obj.Free;  // nicht peng

obj := TTestKlasse.Create;
FreeAndNil(Obj);
obj.Free;  // nicht peng

obj := TTestKlasse.Create;
FreeAndNil(Obj);
FreeAndNil(Obj);  // nicht peng

Ob die Variable nun obj heißt oder ob es eine "Kopie" obj2 gibt, ist hierbei unerheblich ... es kommt immer auf das selbe Prinzip hinaus.

Delphi-Quellcode:

obj := TTestKlasse.Create;
obj2 := obj
obj.Free; // oder FreeAndNil(obj);
obj2 := nil;
obj2.Free;  // nicht peng

Delphi-Quellcode:

obj := TTestKlasse(123456789);
obj.Free; // peng, weil der Zeiger nicht auf eine Objektinstanz zeigt

[Blup]

Um auf die Eingangsfrage zurückzukommen: Die Objekt-Variablen enthalten nur einen Zeiger auf den Speicherbereich, der die Daten des Objektes enthält. Es ist es nicht möglich festzustelllen, ob der Zeiger gültig ist oder das Objekt bereits freigegeben wurde. Deshalb setzt man die Objektvariablen bei Freigabe der Objekte explizit durch Zuweisung oder implizit mit FreeAndNil() auf den Wert Nil (Adresse 0).

Für mehrere Referenzen auf ein Objekt gibt es zwei Wege das Problem zu lösen:
- Observer-Model
- Interfaces
Für schwach Referenzen werden z.T. auch beide Möglichkeiten kombiniert.