create ruft destroy auf???

[ozz]

Hallo Leute,
wie kann es sein, das ein Constructor den Destructor der aufrufenden Klasse aufruft?Ich versuche per
var1:=TTagList.create einen neue Instanz zu erzeugen, jedoch springt der Constructor (auch wenn die auskommentieren Aufruf drin sind) direkt in den Destructor der aufrufenden Klasse. Dann bekomme ich natürlich eine Fehler. In diesem Fall Runtime Error216 at######. Hat jemand einen Tip für mich ?

Vielen Dank!

Delphi-Quellcode:

interface
uses Classes,
     Contnrs,//TObjectList
     Variants;

type TTag = class
FTag: string;
FTag1: string;
FTag2: string;
public
      constructor Create;
      destructor Destroy;override;
      property Tag : String read FTag write FTag;
      property element1 : String read FTag1 write FTag1;
      property element2 : String read FTag2 write FTag2;
end;//Type



type TTagList= class (TObject)

 FTaglist:TObjectlist;
 function Get(Index: Integer): TTag;
 procedure Put(Index: Integer; const Value: TTag);

public
   constructor Create;
   destructor Destroy;override;
   function Add:integer;
   function Additem(Item:TTag):integer;
   procedure Delete(Index:integer);
   function Count :integer;
   property item[Index: Integer]: TTag read Get write Put;
end;

implementation

constructor TTag.create;
begin;
  FTag:=null;
  FTag1:=null;
  FTag2:= null;
  //inherited;
end;

destructor TTag.destroy;
begin;
  //inherited destroy;
end;

constructor TTagList.create;
begin;
  //FTagList:=TObjectList.Create(true);
  //inherited create;
end;

destructor TTagList.destroy;
begin;
  FTagList.Free;
  inherited destroy;
end;

function TTagList.Add: Integer;
var TagType: TTag;
begin
    TagType:=TTag.Create;
    Result:=FTagList.add(TagType);
end;

function TTagList.Additem(Item: TTag): Integer;
var TagType: TTag;
begin
    TagType:=TTag.Create;
    TagType:=Item;
    Result:=FTagList.add(TagType);
end;

function TTagList.count: Integer;
begin
    Result:=FTagList.count;
end;

function TTagList.Get(Index: Integer):TTag;
begin
  result:= TTag(FTagList.Items[Index]);
end;

procedure TTagList.Put(Index: Integer; const Value: TTag);
begin
    FTagList[Index]:=Value;
end;

procedure TTagList.Delete;
begin
    FTagList.Delete(Index);
end;  

end.

[marabu]

Hallo,

du musst auf die richtige Reihenfolge achten:

Delphi-Quellcode:

constructor TTagList.Create;
begin;
  inherited Create;
  FTagList := TObjectList.Create(True);
end;

destructor TTagList.Destroy;
begin;
  FTagList.Free;
  inherited;
end;

Grüße vom marabu

[NormanNG]

Hi,

bei mir funktioniert das ganz normal (mit dem auskommentierten Teil) - auch wenn die Reihenfolge wie beschrieben ist. Auf jeden Fall wird der destructor *nicht* sofort beim create aufgerufen.
Evtl. liegt das Problem wo anders? Zeig mal etwas mehr Beispiel-Code, wo der Fehler bei dir auftritt...

[Jelly]

Ähm, mal ne Frage. Warum nutzt Du nicht gleicht TObjectList anstatt Dir mit TTagList eine nachzubauen... Wenn es nur darum geht, dass die Liste nur Objekte vom Typ TTag aufnehmen darf, wäre es vielleicht sinnvoller eine von TObjectList abgeleitete Klasse zu erstellen.

[ozz]

Hallo NormanNG, hallo Jelly
danke für die Hinweise. Im Prinzip kann ich Tobjectlist nehmen, hatte ich auch bisher. Einige der Funktionen sind auch direkt als Ergänzung zu Tobjectlist gewesen. Ich habe es nur zum Debuggen umgestellt auf Tobject.

Ich habe es mal auf das Wichtigste beschränkt.

Delphi-Quellcode:

type
   TParser = class (TObject)
   ATagParser: TATagParser;
   ParserResult : TTagList;
...

   public
   constructor Create;
   destructor destroy;override;
..
   property TagList:TTagList read ParserResult;
end; //Type

var Parser:TParser;
....
constructor TParser.create;
begin;
 inherited create;
 ParserResult:=Taglist.Create; [b]<--- hier erzeugt er die neue Instanz und landet im TParser.destroy[/b]
.... 

destructor TParser.destroy;
begin
 ParserResult.Free;
 TextResult.Free;
 ATagParser.Free;
 inherited destroy;
end;

///---------------------------------------------------------------
initialization
  Parser := TParser.Create;
finalization
  Parser.free;
end.

[Hawkeye219]

War es vielleicht nur ein Schreibfehler?

Delphi-Quellcode:

constructor TParser.create;
begin;
inherited create;
// ParserResult:=Taglist.Create;
ParserResult:=TTaglist.Create;

Gruß Hawkeye

[yankee]

Mach mal einen Stopp-Punkt in den destructor, warte, bis die IDE reinspringt und schau dir den Call Stack an (Strg+Alt+S, wenn er nicht automatisch offen ist).
Kommt der Aufruf wirklich vom constructor?

[NormanNG]

Hi,
Hawkeye219 hat Recht:

Delphi-Quellcode:

constructor TParser.create;
begin;
inherited create;
 ParserResult:=Taglist.Create; <- hier

an der Stelle kommt es zu einer Exception - und das zuvor erzeugte Object TParser wird sofort wieder zerstört, weil der Konstructor nicht korrekt ausgeführt werden konnte (deshalb der Aufruf des Destruktors).

[ozz]

Hallo Hawkeye, NormanNG, Yankee,
herzlichen Dank. Das war des Rätsels Lösung. Das passiert, wenn Type und Variable sehr ähnlich heißen.

Danke nochmal!