StringList-Objekte wie freigeben?

[PeterPanino]

Ich füge mit AddObject Objekte zu einer Stringliste hinzu:

Delphi-Quellcode:

type
  TMyObj = class
    Feld1: string;
    Feld2: string;
    Feld3: string;
  end;

var
  MyStringList: TStringList;

procedure TForm1.FormCreate(Sender: TObject);
begin
  MyStringList := TStringList.Create;
end; 

//[...]
var
  i: integer;
  NewMyObj: TMyObj;
begin
  for i := x to y do
  begin
    NewMyObj := TMyObj.Create;
    MyStringList.AddObject(AString, NewMyObj);
  end;
//[...]

In FormDestroy wird die StringListe wieder freigegeben. Wie müssen dabei die jeweiligen Objekte freigegeben werden?:

Delphi-Quellcode:

procedure TForm1.FormDestroy(Sender: TObject);
var
  i: integer;
begin
  for i := 0 to MyStringList.Count - 1 do
    MyStringList.Objects[i].Free; //So? Oder FreeAndNil? Oder anders?
  MyStringList.Free;
end;

Oder sollte besser FreeAndNil verwendet werden? Oder etwas anderes?

[Dax]

Ein .Free tuts vollkommen, weils ja eh die Standardmethode ist, ein Objekt wieder loszuwerden, wenn mans nicht mehr sehen will. FreeAndNil setzt die Referenz danach noch auf nil, damit das nächste Free nix falsches tut

[PeterPanino]

Zitat von Dax:

FreeAndNil setzt die Referenz danach noch auf nil, damit das nächste Free nix falsches tut

Kannst du das mal im Detail erklären?

[mkinzler]

Zitat:

Kannst du das mal im Detail erklären?

Wenn du nur .Free aufrufst wird zwar der Speicher freigegeben der Zeiger weist aber immer noch auf den Speicherbereich. Bei .FreeAndNil wird nal dem freigeben die Referenz auf Nil gesetzt. So ist leichter erkennbar ob ein Objekt referenziert wird oder nicht.

[Sharky]

Zitat von PeterPanino:

Kannst du das mal im Detail erklären?

Hai PeterPanino,

eine "Variable" die auf ein TObject zeigt ist nur ein Pointer (Referenz) auf einen Speicherbereich.
Wenn Du nun ein Objekt erzeugst wird der dafür notwendige Speicher reserviert und die "Variable" zeigt auf diesen.
Beim Aufruf von .Free wird nur der reservierte Speicher freigegeben, die Variable zeigt aber noch immer auf eine Speicheradresse.

Wenn Du dir jetzt den Code von TObject.Free ansiehst erkennt man das dieser einen Feher produziert wenn man zweimal .Free für eine Referenz aufruft:

Delphi-Quellcode:

procedure TObject.Free;
begin
  if Self <> nil then
    Destroy;
end;

Da Self ja nicht auf nil gesetzt wird.

Anders ist es bei FreeAndNil. Dort wird nach dem freigeben die Referenz auf nil gesetzt. Darum verursacht ein erneuter Aufruf von .Free keinen Fehler.

Delphi-Quellcode:

procedure TDemoForm.btn_testClick(Sender: TObject);
var
  StringList: TStringList;
begin
  StringList := TStringList.Create;
  StringList.Free;
  StringList.Free; // Fehler. Das Objekt wurde schon zerstört. Nur seine Refernz ist noch da

  StringList := TStringList.Create;
  FreeAndNil(StringList);
  StringList.Free; // Kein Fehler da die Referenz auf nil gesetzt wurde.

  StringList := TStringList.Create;
  StringList.Free;
  StringList := NIL;
  StringList.Free; // Kein Fehler da die Referenz auf nil gesetzt wurde.
end;

[Edit] Da schreibe ich mir die Flossen wund und mkinzler erkärt das in zwei Sätzen

[mkinzler]

@Sharky: Dafür ist deine Erklärung detailierter.

[shmia]

Also ich habe mir für diesen Zweck eine kleine Hilfsfunktion geschrieben,
die ich immer wieder aus der Schublade ziehen kann, wenn ich sie brauche:

Delphi-Quellcode:

{**************************************************************************
 * NAME:    FreeTStringsObjects
 * DESC:    free all Objects attached to a TStrings Object
 * PARAMS:  [-]
 * CREATED: 13-10-2005
 * CHANGED: 00-00-2005
 *************************************************************************}
procedure FreeTStringsObjects(sl: TStrings);
var
   i: Integer;
   o: TObject;
begin
   for i := sl.Count-1 downto 0 do
   begin
      o := sl.Objects[i];
      o.Free;
   end;
end;

PS: Schleifen, die auf 0 runterzählen sind einen Tick schneller als hochzählende Schleifen.

Delphi-Quellcode:

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