Objekte / Freigaben / Free / Nil

[Alex_ITA01]

Hallo zusammen,
ich habe folgendes Beispiel und eigentlich zwei Fragen dazu:

Delphi-Quellcode:

unit Unit4;

interface

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

Type
  TFreeObjList   = Class (TStringList)
    destructor Destroy; override;
  end;

  TMyOwnObject = class
  protected
  private
    Myfrm : TForm;
    function CheckA : boolean;
  public
    a           : SmallInt;
    b           : Double;
    c           : TDateTime;
    d           : AnsiString;
    e           : String[40];
    ObjInternList : TFreeObjList;

    function CheckB : Boolean;

    constructor Create;
    destructor Destroy; override;
  end;

type
  TForm4 = class(TForm)
    Button1: TButton;
    Button2: TButton;
    procedure FormCreate(Sender: TObject);
    procedure FormDestroy(Sender: TObject);
    procedure Button1Click(Sender: TObject);
    procedure Button2Click(Sender: TObject);
  private
    { Private-Deklarationen }
    tmpObject : TMyOwnObject;
    MyObjList : TFreeObjList;
  public
    { Public-Deklarationen }
  end;

var
  Form4: TForm4;

implementation

{$R *.dfm}

{---------------------------------------------------------------------------}
{------------ TFreeObjList- Stringliste mit Freigabe aller Objekte ---------}
{---------------------------------------------------------------------------}
destructor TFreeObjList.Destroy;
Var
  i      : Integer;
  TmpObj : TObject;
begin
  for i:=0 to Count-1 do
  begin
    TmpObj := Objects[i];
    if Assigned(TmpObj) then
      FreeAndNil(TmpObj);
  end;
  Inherited Destroy;
end;
{---------------------------------------------------------------------------}
{ TMyOwnObject }
{---------------------------------------------------------------------------}
function TMyOwnObject.CheckA: boolean;
begin
  Result := A <> 0;
end;
{---------------------------------------------------------------------------}
function TMyOwnObject.CheckB: Boolean;
begin
  Result := B <> 0.0;
end;
{---------------------------------------------------------------------------}
constructor TMyOwnObject.Create;
begin
  Myfrm := TForm.Create(Application);
  ObjInternList := TFreeObjList.Create;

  a := 1;
  b := 2;
  c := Now;
  d := 'Hello';
  e := 'World';
end;
{---------------------------------------------------------------------------}
destructor TMyOwnObject.Destroy;
begin
  ObjInternList.Free;

  if Assigned(ObjInternList) then
    Sleep(0);

  inherited;
end;
{---------------------------------------------------------------------------}
procedure TForm4.FormCreate(Sender: TObject);
begin
  MyObjList := TFreeObjList.Create;
end;
{---------------------------------------------------------------------------}
procedure TForm4.FormDestroy(Sender: TObject);
var
  i    : Integer;
  aObj : TMyOwnObject;
begin
  MyObjList.Free;

  if Assigned(tmpObject) then
  begin
    if tmpObject.CheckA then
      Sleep(0);
    if Assigned(tmpObject.ObjInternList) then
      Sleep(0);
  end;

  if Assigned(MyObjList) then
  begin
    for i := 0 to MyObjList.Count - 1 do
    begin
      aObj := MyObjList.Objects[i] as TMyOwnObject;
      if Assigned(aObj) then
      begin
        if aObj.CheckA then
          Sleep(0);
        if aObj.CheckB then
          Sleep(0);
      end;
    end;
  end;
end;
{---------------------------------------------------------------------------}
procedure TForm4.Button1Click(Sender: TObject);
var
  aObj : TMyOwnObject;
begin
  if Assigned(MyObjList) then
  begin
    aObj := TMyOwnObject.Create;
    MyObjList.AddObject(TimeToStr(aObj.c), aObj);
  end;
end;
{---------------------------------------------------------------------------}
procedure TForm4.Button2Click(Sender: TObject);
begin
  if Assigned(MyObjList) and (MyObjList.Count > 0) then
  begin
    tmpObject := MyObjList.Objects[0] as TMyOwnObject;
    if Assigned(tmpObject) then
      Sleep(0);
  end;
end;
{---------------------------------------------------------------------------}
end.

Die Reihenfolge ist erst den Button1 zu betätigen, dann den Button2.
Da wird sich auf eine gloable Variable der Inhalt des ersten Objektes geholt.

Wenn ich dann die Anwendung beende, passieren eigentlich zwei Dinge:
1) Das Objekt ist immernoch vorhanden und es kann drauf zugegriffen werden obwohl die Liste alle ihre Objekte durchgegangen ist und FreeAndNil gesagt hat

Delphi-Quellcode:

if Assigned(tmpObject) then

2) Vor dem Aufruf von "MyObjList.Free;" enthält das gloable Objekt noch den vollständigen Inhalt (inkl. des AnsiStrings "Hello"). Nach dem Aufruf von "MyObjList.Free;" ist bei dem globalen Objekt bis auf dem AnsiString noch alle vorhanden. Der AnsiString ist auf einmal nicht mehr "Hello" sondern ein Leerstring. Ich hätte doch dann jetzt erwartet, dass entweder alles weg ist (=Nil) oder noch alles da ist.

Könnt ihr mich hier mal bitte aufklären?
Umgebung = XE4

Gruß

[Uwe Raabe]

Delphi-Quellcode:

    
    TmpObj := Objects[i];
    if Assigned(TmpObj) then
      FreeAndNil(TmpObj);

Mal abgesehen davon, daß das if Assigned überflüssig ist, setzt FreeAndNil nur TmpObj auf nil, nicht aber Objects[I].

Strings haben eine implizite Referenzzählung und der Compiler behandelt sie bei Klassen und Records anders als andere Typen.

[baumina]

Ich würde im Destroy lieber rückwärts freigeben, also statt for i:=0 to Count-1 lieber for i:=Count-1 downto 0.

[generic]

Delphi-Quellcode:

 TFreeObjList = Class (TStringList)

Du kannst auch die TObjectList nutzen. Diese kann Objekte auch selbst freigeben.

[Alex_ITA01]

@baumina:

Zitat:

Ich würde im Destroy lieber rückwärts freigeben, also statt for i:=0 to Count-1 lieber for i:=Count-1 downto 0.

Darf ich fragen warum?

@Uwe Raabe:
Was müsste ich denn machen, um das Object[i] als solches auch freizugeben und auf Nil zu setzen?

Gruß

[DeddyH]

Delphi-Quellcode:

FreeAndNil(Objects[i]);

Wobei mir nicht klar ist, wozu genilt werden soll, wenn die Liste danach eh futsch ist.

[mkinzler]

Delphi-Quellcode:

Darf ich fragen warum?

weil sich u.U. durch Löschen der Index ändern könnte

[Union]

Zitat:

Zitat von Alex_ITA01 (Beitrag 1231423)

@baumina:

Zitat:

Ich würde im Destroy lieber rückwärts freigeben, also statt for i:=0 to Count-1 lieber for i:=Count-1 downto 0.

Darf ich fragen warum?

@Uwe Raabe:
Was müsste ich denn machen, um das Object[i] als solches auch freizugeben und auf Nil zu setzen?

Gruß

Weil die Liste jedesmal schrumpft und Du die Anzahl der Elemnte überschreitest. Also entweder mit

Delphi-Quellcode:

for ... downto

oder mit

Delphi-Quellcode:

while count > 0

[Namenloser]

Zitat:

Zitat von Alex_ITA01 (Beitrag 1231423)

@baumina:

Zitat:

Ich würde im Destroy lieber rückwärts freigeben, also statt for i:=0 to Count-1 lieber for i:=Count-1 downto 0.

Darf ich fragen warum?

Vielleicht kann es nicht schaden, sich das zur Gewohnheit zu machen, denn wenn man z.B. statt FreeAndNil Delete aufruft, bekommt man sonst Probleme. Aber eigentlich ist es hier unnötig...

Edit: Eine andere Sache, die mir an dem Code hier auffällt, ist allerdings die völlige Sinnlosigkeit von FreeAndNil. Die Prozedur gibt dir hier nur falsche Sicherheit, denn alles was sie tut, ist, die lokale Variable auf nil zu setzen. In der Liste selbst ändert sich nichts. Ach das Prüfen mit Assigned ist daher völlig sinnlos und erschwert höchstens die Fehlersuche.

[DeddyH]

Seit wann schrumpft eine TStringlist, wenn ich deren Objekte freigebe?