Klasse in einer Klasse Destruktor

[kagi3624]

Zitat von Der schöne Günther:

Ganz genau. Der Destruktor wird auch immer ausgeführt, auch wenn der Konstruktor scheiterte, z.B. eine Exception auftritt.

Ich habe aber gerade gesehen, dass mein destructor nicht (explicit) ? aufgerufen wird, wenn ich nur Foo.Free; habe. Erst wenn ich ein override; hinter dem Destructor habe, wird dieser mit Free aufgerufen.

[Der schöne Günther]

Destruktoren sind in Delphi quasi als virtuelle Methode implementiert. Du hättest da auch eigentlich eine Compiler-Warnung bekommen müssen.

Hier einmal als Minimalbeispiel zum Ausprobieren:

Delphi-Quellcode:

program Project1;

{$APPTYPE CONSOLE}
{$R *.res}

uses System.SysUtils;

type
   TMyObject = class
      destructor Destroy(); {override;}
   end;

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

var
   myObject: TObject;
begin
   myObject := TMyObject.Create();
end.

[Rollo62]

Delphi-Quellcode:

var
   myObject: TObject;
begin
   myObject := TMyObject.Create();
   ...
   myObject.Free; //<===
end.

Das würde ich noch ergänzen, damit das Free -> Destroy klar wird.

[kagi3624]

Hmm..was macht denn das 'inherited' in dem Destruktor? Es wird doch von keienr Klasse geerbt?

[Der schöne Günther]

Alle Delphi-Klassen stammen von TObject ab. Das TObject bringt sowohl den Standard-Konstruktor Create() als auch den Standard-Destruktor Destroy() mit.

Wenn du einen eigenen Destruktor hast, dann solltest du auch wirklich immer ein inherited drin haben. Ja, wenn man seine Klasse direkt von TObject ableitet könnte man es sich sparen. Aber warum nicht? Angenommen deine Klasse TMySpecialization hat sich ursprünglich nicht von TMyBase abgeleitet, jetzt aber schon. Und du hättest in deinem Destruktor von TMySpecialization das inherited nicht drin gehabt. Dann hättest du jetzt ein Speicherleck (oder eventuell schlimmeres) da der Destruktor von TMyBase (und allem darüber) nicht mehr ausgeführt würde.

Delphi-Quellcode:

type
  TMyBase = class // man könnte ebenso schreiben "TMyBase = class(TObject)"
    private var
      someStuff: TObject;
    public
      constructor Create();
      destructor Destroy(); override;
  end;

  TMySpecialization = class(TMyBase)
    public
      constructor Create();
      destructor Destroy(); override;
  end;

{ TMySpecialization }

constructor TMySpecialization.Create();
begin
  inherited; // sowas von überhaupt nicht überflüssig
  // (...)
end;

destructor TMySpecialization.Destroy();
begin
  // (...)
  inherited; // sowas von überhaupt nicht überflüssig
end;

{ TMyBase }

constructor TMyBase.Create();
begin
  inherited; // streng genommen überflüssig, aber warum nicht?
  someStuff := TObject.Create();
end;

destructor TMyBase.Destroy();
begin
  someStuff.Free();
  inherited; // GANZ streng genommen überflüssig, aber warum nicht?
end;

[DeddyH]

Moooment: versuch einmal, eine Variable vom Typ TMyBase zu deklarieren und ihr eine Instanz von TMySpecialization zuzuweisen. Was geschieht dann mit dem Konstruktor von TMySpecialization (Haltepunkt)?

Delphi-Quellcode:

procedure WhatKnowThenI;
var
  SomeInstance: TMyBase;
begin
  SomeInstance := TMySpecialization.Create;
  SomeInstance.Free;
end;

[himitsu]

Zitat:

Delphi-Quellcode:

constructor TMyBase.Create();
begin
  inherited; // streng genommen überflüssig, aber warum nicht?
  someStuff := TObject.Create();
end;

destructor TMyBase.Destroy();
begin
  someStuff.Free();
  inherited; // GANZ streng genommen überflüssig, aber warum nicht?
end;

Überflüssig ist da garnichts.

Wenn du jetzt mit absoluter Sicherheit sagen kannst, dass jetzt und auch in zukunft in den Methoden des Vorfahren niemals Code sein wird, dann ist es "unnötig".
Wenn nicht, dann sollte man es besser immer einfügen.

Wenn es "gerade jetzt" nicht benötigt wird, weil es keine gleichnamige Methode im Vorfahren gibt, dann lässt der Compiler das inherited im Kompilat weg.

[Hobbycoder]

Zitat von kagi3624:

Zitat von Der schöne Günther:

Ganz genau. Der Destruktor wird auch immer ausgeführt, auch wenn der Konstruktor scheiterte, z.B. eine Exception auftritt.

Ich habe aber gerade gesehen, dass mein destructor nicht (explicit) ? aufgerufen wird, wenn ich nur Foo.Free; habe. Erst wenn ich ein override; hinter dem Destructor habe, wird dieser mit Free aufgerufen.

Ich mach das immer so, dass ich bereits beim erstellen der Destructor-Methode mit dem Code-Insight arbeite. Einfach zwischen TFoo=class und end; STRG+Leertaste, Exec eingeben, dann steht das schon Execute, und mit Enter bestätigen. Code-Insight erstellt die Destuctor-Methode gleich korrekt und legt auch den Public-Abschnitt gleich mit an, wenn nötig.
Spart Zeit und man kann das unscheinbare override nicht vergessen (passierte mir früher regelmäßig).

Übrigens: mit Shift+CTRL+C wird werden auch die Methoden gleich im Implementation-Abschnitt erstellt.

Leider klappt das mit dem Constructor nicht ganz so komfortabel.