Klasse in einer Klasse Destruktor

[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.