Komponeten zerstören

[LoL]

hi

ich erzeuge komponeten zur laufzeit. nun will ich diese zerstören. ich will dafür ne allgemein prozedur verwenden etwa so:

Delphi-Quellcode:

procedure Destroy_Component(Compo : TComponent);
begin
  if Compo <> nil then
    begin
      Compo.Destroy;
      Compo := nil;
      Compo.Free;
    end;
end;

das zerstören klappt auch so weit.
wenn ich aber diese komponenten die zerstört ist, wieder erstellen will frage ich

Delphi-Quellcode:

if not(assigned(Compo )) then <--Compo ist die zertörte komponete
....
erstellen der komponente

diese abfrage ist aber false!, d.h. die komponente existiert noch.

wenn ich aber die komponete ohne diese prozedur zerstöre also manuell(z.b. ein panel):

Delphi-Quellcode:

panel.destroy;
panel := nil;
panel.free;

und dann die abfrage mache ob die komponente noch existiert ist diese true! obwohl ich das selbe gemacht habe?

wer kann mir helfen

[Dagon]

Versuchs mal mit FreeAndNil:

Delphi-Quellcode:

procedure Destroy_Component(Compo : TComponent);
begin
  if Compo <> nil then
    FreeAndNil(Compo);    
end;

[LoL]

will ich nicht kannst du mir sagen woran es liegt

[Dagon]

1. Mit Assignde prüfst du ob der Zeiger (hier Compo) den Wert nil hat.

2. Folgendes steht in der OH:

Zitat:

Assigned gibt false zurück, wenn P den Wert nil hat, andernfalls true.

[LoL]

wenn ich die komponente nach obiger prozedur zertöre und frei gebe dann ist sie nil: also warum gibt dann assign true zurück?

[Chewie]

Ersetz mal

Delphi-Quellcode:

procedure Destroy_Component(Compo : TComponent); 
begin 
  if Compo <> nil then 
    begin 
      Compo.Destroy; 
      Compo := nil; 
      Compo.Free; 
    end; 
end;

durch

Delphi-Quellcode:

procedure DestroyComponent(Compo: TComponent);
begin
  if Compo <> nil then
  begin
    Compo.Free;
    Compo := nil;
  end;
end;

[Dagon]

Es gibt false zurück!

Du hast ja geschrieben if not(assigned(Compo)) = true ....
Das würde also beduten, diese Aussage ist wahr, wenn Assigned False zurückgibt.

Ergo: Compo ist Nil!

[LoL]

Die Funktion Assigned prüft, ob ein Zeiger oder eine Prozedurvariable den Wert NIL hat (nicht zugewiesen ist).

if Assigned(Component) then //Instanz erstellt

ich frage ja bevor ich die komponete erstelle ob sie nil ist. falls sie nämlich scho existiert bekomme ich ja ne exception!

[Dagon]

Das ist genau das was ich gemeint habe.

[LoL]

also passt die abfrage aber was ist der unterschied zwischen dem zerstören in der prozedur und der manuellen zerstörung?

[ArrayOf..]

Du destroyst die Componente zwar, aber du NIL'st nur die temporäre Variable 'Compo' dieser Procedure 'Destroy_component'. Die TComboBox-Instanz die du beim Aufruf dieser Procedure in der Parameterliste mitgegeben hast wird zwar so auch freigegeben aber eben nicht geNILt, weil es zwei unterschiedliche Ptr-Variablen sind.

Der Ptr in deiner Procedure-Parameterliste übernimmt den Ptr-Wert auf die zu löschende CompoBox, wodurch deren Speicher dann freigegeben wird. Anschließend wird aber nur dein Ptr in der Procedure geNILt und eben nicht der 'draußen'.

Versuche mal in deinem Procedurekopf diese 'Compo'-Variable als 'var' zu declarieren:

procedure Destroy_Component(var Compo : TComponent);

[LoL]

ok so weit so gut aber wenn ich das so ändere und compilieren will dann erhalte ich folgende fehlermeldung:

Zitat:

Types of actual and formal var parameters must be identical

Delphi-Quellcode:

procedure Destroy_Component(var Compo : TComponent);
begin
  if Compo <> nil then
    begin
      Compo.Destroy;
      Compo := nil;
      Compo.Free;
    end;
end;

//beim panel zerstören:
Destroy_Component(beispielpanel);

zu deutsch

Bei einem Variablenparameter muß das eigentliche Argument genau denselben Typ wie der formale Parameter aufweisen.

was mache ich falsch

[Christian Seehase]

Moin Christoph,

nimm TObject und nicht TComponent.
TObject ist der Vorfahr für alle.

[LoL]

Zitat:

Zitat von Christian Seehase

nimm TObject und nicht TComponent.
TObject ist der Vorfahr für alle.

das gleiche....
mit TPanel gehts auch net

[Christian Seehase]

Moin Christoph,

probier's mal so:

Delphi-Quellcode:

procedure Destroy_Component(Compo : TObject);
begin
  if Compo <> nil then
    begin
      Compo.Free;
      Compo := nil;
    end;
end;

[Dagon]

Ist das nicht das selbe wie

Delphi-Quellcode:

procedure Destroy_Component(Compo : TObject); 
begin 
  if Compo <> nil then 
    begin 
      FreeAndNil(Compo); 
    end; 
end;

:?:

[LoL]

der akzeptiert ja scho nicht mal die übergabe parameter

[ArrayOf..]

Ne, ich weiß nicht ob das überhaupt geht. Du musst ja nachher auch den entsprechend zu deinem Objekt korrekt passenden klassenrefferenzierten Destructor aufrufen und das wird in dieser Destroy-Routine wahrscheinlich nicht so einfach möglich sein, wenn überhaupt, imo.

[LoL]

also kann man nicht eine prozedur schreiben die jede art von komponeten zerstört und frei gibt?

[Christian Seehase]

Moin The Master,

Du hast doch die Pro Version.
Schau Dir mal in den Sourcen an wie FreeAndNil implementiert ist.

[ArrayOf..]

@LoL

ich möchte hier nicht den Experten vorgreifen, aber ich glaube es eher weniger.

[Dagon]

@ Christian Seehase: Ich mich :oops:

[Christian Seehase]

Moin Christoph,

Zitat:

Zitat von LoL

also kann man nicht eine prozedur schreiben die jede art von komponeten zerstört und frei gibt?

Die gibt es schon. Die heisst FreeAndNil.

[EDIT]

Zitat:

Zitat von the_master

@ Christian Seehase: Ich mich :oops:

Warum das denn? Man kann ja nicht immer an alles denken.
[/EDIT]

[LoL]

freeandnil macht das:

Delphi-Quellcode:

procedure FreeAndNil(var Obj);
var
  Temp: TObject;
begin
  Temp := TObject(Obj);
  Pointer(Obj) := nil;
  Temp.Free;
end;´

hab ich probiert geht aber irgendwie nicht. die abfrage gibt immer noch false zurück

[ArrayOf..]

ich nehm an, FreeAndNil benötigt in seiner Parameterliste aber immer eine Instanz deren Typ ursprünglich ist und nicht eine deren Typ durch eine Übergabe via Parameterliste erst noch quasi 'falsch' ge-typcastet wurde.

[Chewie]

Also: Ich nehm an, Beispielpanel ist vom Typ TPanel.
Dann sollte folgender Aufruf funktionieren:

Delphi-Quellcode:

destroy_components(TComponent(Beispielpanel));

[ArrayOf..]

nein eigentlich gerade nicht. Ich formuliere dann, dass das Teil vom Typ TComponent wäre, FreeAndNil muss aber den Destructor von TPanel aufrufen. Ich weiß nicht ob die Routine das dann trotzdem noch so ohne weiteres kann.

[Chewie]

No prob. Das ist ja das schöne von Klassen: Eine Objektvariable ist ja nur ein Zeiger auf das Objekt. Durch den Cast des Panels in TComponent kann man zwar nur noch auf die Eigenschaften und Methoden von TComponent zugreifen, der Inhalt bleibt aber der gleiche. Es wird weiterhin der Destruktur von TPanel aufgerufen.

[ArrayOf..]

Bist du sicher, also dass nach einem falschen Typcasting per Übergabe via Parameterliste immer noch der korrekte Destructor aufgerufen wird? Wo doch die typisierte Instanz-Variable auch sonst immer den Typ des gepointeten quasi entscheident bestimmt. Du sagst ja selbst, dass man dann nur noch auf die Eigenschaften und Methoden von TComponent zugreifen kann. Der Destructor ist aber prinzipiell auch nur eine dieser Methoden. Also ich glaub's eher nicht so richtig... Aber ich muss auch zugeben, 1000% weiß ich es hier auch nicht *g*.


edit: Und meines Wissens sind solche Destructoren auch nicht so eine Abart von diesen virtuellen Methoden, die ja irgendwie so eine ähnliche Fähigkeit besitzen.

[Chewie]

Du castest ja nur den Pointer, nicht den Inhalt! Welche Methode aufgerufen wird, bestimmt der Typ zur Laufzeit, nicht der im Quelltext angegebene!

Probiers mal selber aus:

Delphi-Quellcode:

type
  TMyObject = class
  public
    destructor Destroy; override;
  end;

destructor TMyObject.Destroy;
begin
  ShowMessage('Ich werde ausgeführt');
end;

var
  Obj: TObject;
begin
  Obj := TMyObject.Create;
  Obj.Free;
end;

[Christian Seehase]

Moin Chewie,

nur um mal die, nicht vorhandene, Problematik mit dem Typecast vorzuführen:

Delphi-Quellcode:

type
  TMyPanel = class(TPanel)
  public
    destructor Destroy; override;
  end;

implementation

{$R *.DFM}

destructor TMyPanel.Destroy;
begin
  ShowMessage('und kaputt...');
  inherited;
end;

procedure TForm1.Button1Click(Sender: TObject);

var
  mp : TMyPanel;

begin
  mp := TMyPanel.Create(self);
  TComponent(mp).Free;
end;

[ArrayOf..]

stimmt, das mit dem Typcasting ist tatsächlich kein Problem. Hätte ich ehrlich nicht gedacht... gut, gut.