Objekte in Klassen: Was wird alles zerstört?

[GuenterS]

Zitat von malo:

Zitat von GuenterS:

Hm Du solltest im Destructor von SuperKlasse auch nur Klasse B freigeben (mit Free), dadurch wird der Destructor der Klasse B aufgerufen wo Du dann Klasse A freigeben kannst.

Aber ich krieg auch eine Exception, wenn ich KlasseB freigeben will. Das ist das seltsame...

Zitat von GuenterS:

Poste doch mal den Code, womit Du Probleme hast, dann kann man sicher leichter helfen.

Wollte ich eigentlich auch machen, allerdings sitze ich grade am falschen Rechner und hab keinen Zugriff auf meine Sourcen. Daher hab ich versucht das Problem mit meinem Beispiel oben zu beschreiben. Wenn ich wieder an meinem PC bin, werd ich den entspr. Source posten

Ich gehe davon aus, dass Du KlasseB auch erzeugt hast in SuperKlasse?

Delphi-Quellcode:

constructor TSuperKlasse.create;
begin
  ...
  KlasseB := TKlasseB.Create;
end;
...

destructor TSuperKlasse.destroy;
begin
  KlasseB.Free;
  ...
end;

[ichbins]

Der Fehler beim Freigeben von Klasse B liegt vielleicht daran dass der Inhalt des Pointers auf KlasseB schon geleert wurde. Jedenfalls wird die Klasse nicht freigegeben:

Delphi-Quellcode:

var
  a:array[1..1000000] of tsuperklasse;
  i:integer;
begin
  for i:=low(a) to high(a) do begin
    sk:=tsuperklasse.Create;
    sk.klasseb:=tklasseb.create;
    sk.klasseb.klassea:=tklassea.Create;
    sk.Free;
  end;
end;

Der RAM-Verbrauch der Anweundung steigt jedesmal um einige MB an.

[GuenterS]

Zitat von ichbins:

Der Fehler beim Freigeben von Klasse B liegt vielleicht daran dass der Inhalt des Pointers auf KlasseB schon geleert wurde. Jedenfalls wird die Klasse nicht freigegeben:

Delphi-Quellcode:

var
  a:array[1..1000000] of tsuperklasse;
  i:integer;
begin
  for i:=low(a) to high(a) do begin
    sk:=tsuperklasse.Create;
    sk.klasseb:=tklasseb.create;
    sk.klasseb.klassea:=tklassea.Create;
    sk.Free;
  end;
end;

Der RAM-Verbrauch der Anweundung steigt jedesmal um einige MB an.

Hm, ja aber ohne jetzt die jeweiligen Destructoren zu sehen, geh ich mal von den Standard destructoren aus und damit is klar, dass weder KlasseB noch die in KlasseB enthaltene KlasseA freigegeben wird, womit sich auch der vermehrte Ramverbrauch erklärt.

[sniper_w]

Wo es geht, würde ich empfehlen, die Prodeduren "AfterConstruction" und "BeforeDestruction" zuüberschreiben, anstatt Constructor bzw. Destructor.

[tigerman33]

Warum?

[malo]

Zitat von sniper_w:

Wo es geht, würde ich empfehlen, die Prodeduren "AfterConstruction" und "BeforeDestruction" zuüberschreiben, anstatt Constructor bzw. Destructor.

Danke. Scheinbar war das Objekt wohl schon zerstört, wodurch keine Zugriffe mehr möglich waren...


Danke auch an alle anderen für die Mühen

[GuenterS]

Zitat von malo:

Zitat von sniper_w:

Wo es geht, würde ich empfehlen, die Prodeduren "AfterConstruction" und "BeforeDestruction" zuüberschreiben, anstatt Constructor bzw. Destructor.

Danke. Scheinbar war das Objekt wohl schon zerstört, wodurch keine Zugriffe mehr möglich waren...


Danke auch an alle anderen für die Mühen

Kann es sein, dass Du im Destructor zuerst "inherited" aufgerufen hast und erst danach versucht hast Deine Objekte freizugeben?

[malo]

Zitat von GuenterS:

Kann es sein, dass Du im Destructor zuerst "inherited" aufgerufen hast und erst danach versucht hast Deine Objekte freizugeben?

Ich hab im Destructor gar nichts aufgerufen. Nur die Objekte zerstört...

[alzaimar]

Tut mir leid, ich halte Vieles von dem, was hier gepostet wurde, für überflüssig und irreführend. Jede Klasse sollte sich 'um seinen eigenen Kram' kümmern, und zwar so (eigentlich ganz einfach):

Delphi-Quellcode:

type TKlasseA = class
    a: integer; //irgend ein Feld, ist ja egal, was es genau ist
  end;
  TKlasseB = class
  Private
    FKlasseA: TKlasseA;
  Public
    Constructor Create;
    Destructor Destroy; Override;
    Property ZugriffAufA : TKlasseA Read FKlasseA;
  end;
  TSuperKlasse = class
  Private
    FKlasseB: TKlasseB;
  Public
    Destructor Destroy; Override;
    Property ZugriffAufB : TKlasseB Read FKlasseB;
  end;

Constructor TKlasseB.Create;
Begin
  Inherited Create;         // unnötig, schadet aber nicht
  KlasseA := TKlasseA.Create;     // Was ich erschaffe ...
End;

Destructor TKlasseB.Destroy; // <--hier war ein kleiner Rechtschreibfehler
Begin
  FreeAndNil (KlasseA); // ... zerstöre ich auch wieder ...
  Inherited;
End;

Constructor TSuperKlasse.Create;
Begin
  Inherited Create;          // unnötig, schadet aber nicht
  KlasseB := TKlasseB.Create;      // Was ich erschaffe ...
End;

Destructor TSuperKlasse.Destroy;
Begin
  FreeAndNil (KlasseB); // ... zerstöre ich auch wieder ...
  Inherited;
End;

Vorausgesetzt, ich hab hier keinen Bockmist gemacht, klappt das Immer. Ohne BeforeDestruction oder AfterDestruction. Wenn man das als eiserne Regel befolgt ("Was ich erschaffe, zerstöre ich auch") und dann noch Resourcenschutzblöcke (Try..Finally) verwendet, baut auch sichere, also stabile und exploitresistente(re) Programme.

[tigerman33]

Rechtschreibfehler:

Delphi-Quellcode:

Destructor TKlasseA.Destroy; <-- genau hier
Begin
  FreeAndNil (KlasseA); // ... zerstöre ich auch wieder ...
  Inherited;
End;

Das muss natürlich KlasseB sein.

Ich wüsste aber immer noch gern den Vorteil von BeforeDestruction vs. Destroy.