Verunsicherung mit Destructor, Free und FreeAndNil

[arc]

Ich habe eine eigene Klasse die z.B. so aussieht:

Delphi-Quellcode:

type TBasicModuleList = class
                   protected
                     list:TList;

                   public
                     constructor init; virtual;
                     function add(module:TModule):TModule;
                     procedure delete(module:TModule);
                     function getItem(index:integer):TModule;
                     function getCount:integer;
                     function getModuleByID(id:integer):TModule;
                     procedure FlushList; virtual;
                     destructor done; virtual;
                   end;

Ein Objekt erzeuge ich dann so

Delphi-Quellcode:

var mlist:TBasicModuleList;
begin
  mlist:=TBasicModuleList.init;
end;

Nun meine Frage, wenn ich den Destructor aufrufe, muß ich anschließend noch .Free aufrufen? Falls nein, kann ich meinen Destructor ebenfalls Free nennen damit ich z.B. FreeAndNil() nutzen kann?

Ich suche im Moment einen Pointerbug und stelle meinen Code entsprechend auf FreeAndNil um...

Danke!

[schlecki]

Hallo arc,

ein Constructor sollte in der Regel "Create" heißen. Der Destructor muss auf jeden Fall "Destroy" heißen. Wichtig ist beim Desctructor auch, dass er als "override;" deklariert wird.

Delphi-Quellcode:

type
  TMyClass = class(...)
  public
    constructor Create(); reintroduce;
    destructor Destroy(); override;
    ...
  end;

...

constructor TMyClass.Create();
begin
  inherited Create();
  ...
end;

destructor TMyClass.Destroy();
begin
  ...
  inherited;
end;

Dein Destructor wird dann auch von Free und FreeAndNil (welches intern wieder Free aufruft ) genutzt.

[arc]

Vielen Dank, dann werde ich meinen Code entsprechend ändern.

[himitsu]

Sollte und müßte sind soeine Sache.

Es muß nicht, aber es hat sich so eingebürgert.

Delphi-Quellcode:

type TBasicModuleList = class
  public
    constructor init; virtual;
    destructor done; virtual;

    destructor Destroy; override;
  end; 

constructor TBasicModuleList.init;
begin
  inherited Create;  // *1
  ...
end;

destructor TBasicModuleList.done;
begin
  ...
  inherited Destroy;  // *2
end;

destructor TBasicModuleList.Destroy;
begin
  done;  // *3
end;

*1
könnte man weglassen, aber besser man schreibt es immer, bevor man es mal vergißt

*2
wie schlecki schon sagte, dieses sollte man besser auch aufrufen
(obwohl man es hier auch weglassen könnte)

Grund: der Constructor und Destructor von TObject ist leer

*3
falls der originale Destructor aufgerufen wird, muß der neue Destructor auch mit ausgeführt werden.




Der Destructor muß virtuell sein, damit immer der aktuelle ausgeührt wird, welcher zum erzeugten Objekt gehört, egal über welchen Klassentypen (Typ der Variable, bzw. des Funktions-Parameters) er aufgerufen wird.

Der Constructor muß nicht virtuell sein, es sei denn man ruft ihn über einen Klassenvariable (class of ...) auf, wo man natürlich auch auf den aktuellen Contructor zugreifen will. (siehe TComponent der VCL)






Also, alles ist möglich, aber um Verwirrungen zu vermeiden, ist es nicht unbedingt zu empfehlen





PS: Da man den Destructor doch eh nicht direkt aufrufen soll.

Delphi-Quellcode:

type TBasicModuleList = class
  public
    constructor init; virtual;
    destructor destroy; override;

    function done;
  end;

constructor TBasicModuleList.init;
begin
  inherited Create;
  ...
end;

destructor TBasicModuleList.destroy;
begin
  ...
  inherited;
end;

function TBasicModuleList.done;
begin
  Free;
end;

"init" zum Erstellen ala "Create" und "done" zum Freigeben "Free".

Jetzt darf man bei Vererbungen nur nicht vergessen, daß Create nicht mehr verwendet werden darf (das ist bei den anderen Beispielen auch der Fall).
Und beim Freigeben bleibt die Linie über Destroy erhalten. (hier hätte man sonst auch beim "done" aufpassen müssen, daß bei Vererbungen Destroy ebenfalls nicht wiederverwendet wird.)

Darum vielleicht noch einen Schutz mit verbauen.

Delphi-Quellcode:

type TBasicModuleList = class
  public
    constructor create;
    destructor destroy; override;

    constructor init; virtual;
    function done;
  end;

constructor TBasicModuleList.create;
begin
  raise Exception.Create('create darf nicht verwendet werden');
end;

destructor TBasicModuleList.destroy;
begin
  ...
  inherited;
end;

constructor TBasicModuleList.init;
begin
  inherited Create;
  ...
end;

function TBasicModuleList.done;
begin
  Free;
end;

zusätzlich vielleicht auch noch dieses versuchen
(obwohl es gegen die OOP-Richtlinien verstößt, könnte man versuchen create und destroy auszublenden)

Delphi-Quellcode:

type TBasicModuleList = class
  protected
    constructor create;
    destructor destroy; override;
  public
    constructor init; virtual;
    function done;
  end;

[hoika]

Hallo,

und noch das:

Der destructor Destroy wird nicht zum Zerstören der Klasse aufgerufen, sondern Free.

FreeAndNIL ist nichts anderes als ein Free und nachfolgendes NIL-Setzen.


Heiko

[HeikoAdams]

Und obendrein wird in der Online Hilfe auch explizit davon abgeraten, destroy aus dem Programmcode heraus aufzurufen.

Zitat von Online Hilfe für TObject.Destroy:

Rufen Sie Destroy nicht direkt auf. Verwenden Sie stattdessen Free . Die Methode Free überprüft, ob die Objekt-Referenz nicht bereits nil ist und ruft Destroy nur bei Bedarf auf.

[FredlFesl]

Zitat von hoika:

Der destructor Destroy wird nicht zum Zerstören der Klasse aufgerufen, sondern Free.

Also, Destroy wird schon zum Zerstören der Klasse aufgerufen, schließlich ist das der Destruktor.

Man kann 'destroy' aufrufen. Ohne Probleme. Wenn man sich seiner Sache sicher ist. Hie z.B.

Delphi-Quellcode:

MyObject := TMyObject.Create;
Try
  MyObject.Do;
Finally
  MyObject.Destroy; // <-- Ich kann sicher sein, das MyObject instantiiert ist.
End;

Zitat von HeikoAdams:

Und obendrein wird in der Online Hilfe auch explizit davon abgeraten, destroy aus dem Programmcode heraus aufzurufen.

Siehe oben. Man fragt sich, warum.

Der einzige Grund 'Free' aufzurufen, ist doch der:
Wenn man mal 'Free' und mal 'Destroy' verwendet, ist das nicht sauber. Da Free bei unsauberer Programmierung robuster ist, verwenden wir eben immer Free. Außerdem machen das Alle.

Und wenn man wirklich rumschlampen will, nimmt man eben immer 'FreeAndNil'. Dann ist man entgültig auf der sicheren Seite. Man produziert zwar überflüssigen Code, aber wem das egal ist, bitte sehr.

Bitte nicht falsch verstehen: FreeAndNil ist manchmal sehr praktisch aber eben nicht immer.

[bernau]

Zitat von himitsu:

Sollte und müßte sind soeine Sache.

Es muß nicht, aber es hat sich so eingebürgert.

Eben weil es sich eingebürgert hat, solle man es auch verwenden.

Man selber denkt vieleicht daran, daß man Init als Constructor aufruft. Wenn aber das Objekt mal von jemand anderem Verswendet wird, kann es sein, daß der jenige Create statt Init verwendet (weil immer noch verfügbar). Dann fehlen ggf. wichtige Funktionen, die zum Erzeugen des Objektes wichtig sind. Das gleiche gilt natürlich für den Destructor.

[Christian Seehase]

Moin Himitsu,

Zitat von himitsu:

(obwohl man es hier auch weglassen könnte)

Grund: der Constructor und Destructor von TObject ist leer

...und der Grund warum inherited beim Constructor und Destructor auch eingebaut werden sollten, wenn TObject die Basisklasse ist:

Niemand kann wissen, ob Constructor und Destructor von TObject in künftigen Delphi-Versionen auch leer sein werden. Das könnte bei der Verwendung der Klasse zu Problemen führen.

[arc]

Vielen Dank für die rege Diskussion! Wenn ich also den Destructor als Destroy implementiere und das Objekt via FreeAndNil() zerstöre paßt alles? Das ruft ja entsprechend Free auf, was wiederum bei Bedarf meinen Destructor aufruft.