Mehrere Klasseninstanzen in einem Array/einer TList

[Marphy]

Hallo zusammen,
mal wieder beschäftigt mich ein Problem, das ich auch nach längerem Rätseln und Tüfteln nicht allein bewältigen konnte. :wall:

Ich habe in meinem Projekt zwei Klassen, nennen wir sie TMainClass und TSubClass. TMainClass hat einen Member, nämlich eine TList bzw. ein Array (was sich besser eignet, ist glaube ich die TList - dies variiert aber je nach möglicher Lösung) und eine Funktion, nennen wir sie CreateInst(), welche folgendes tut:

Delphi-Quellcode:

function TMainClass.CreateInst(): Integer;
   var oObj: TSubClass;
begin
   // Instanz von TSubClass erstellen
   oObj := TSubClass.Create();
   
   with oObj do begin
      // Properties setzen...
   end;
   
   // Instanz der Liste (Klassenmember) hinzufügen
   // und Listenindex zurückgeben
   Result := oList.Add(@oObj);
end;

Diese Prozedur kann beliebig oft aufgerufen werden.
Eine andere Methode der TMainClass, nennen wir sie AccessInst(), soll nun auf eine beliebige TSubClass-Instanz, die zuvor mittels CreateInst() erstellt und der Liste oList hinzugefügt wurde, zugreifen; z. B. so:

Delphi-Quellcode:

procedure TMainClass.AccessInst(Idx: Integer);
begin
   with TSubClass(oList[Idx]^) do begin
      // Auf TSubClass zugreifen
      //   --> FUNKTIONIERT NICHT!
   end;
end;

Nun, wahrscheinlich wird die erstellte TSubClass-Instanz beim Verlassen der CreateInst()-Funktion zerstört, weswegen später nicht mehr auf sie zugegriffen werden kann.... Hier ein kleines Beispiel (Code kann irdendwo stehen, z. B. in einem Click-Event):

Delphi-Quellcode:

// TMainClass erstellen
oMainClass := TMainClass.Create();

// Ein paar TSubClass-Instanzen erstellen
oMainClass.CreateInst();
oMainClass.CreateInst();
iIdx := oMainClass.CreateInst();
oMainClass.CreateInst();

// Auf 3. Klasseninstanz zugreifen
//   --> funktioniert nicht!
oMainClass.AccessInst(iIdx);

Natürlich wurde oList im Create-Konstruktor von TMainClass zuvor erstellt, und natütlich sind alle Variablen auch ordnungsgemäß deklariert.

Nun meine Frage: Wie kann man die obig beispielhaft präsentierte Situation richtig angehen?

Vielen Dank für eure Hilfe! :thumb:

Viele Grüße,
Marco

[shmia]

Zitat:

Zitat von Marphy

Ich habe in meinem Projekt zwei Klassen, nennen wir sie TMainClass und TSubClass. TMainClass hat einen Member, nämlich eine TList bzw. ein Array (was sich besser eignet, ist glaube ich die TList - dies variiert aber je nach möglicher Lösung)

Eine TList ist definitiv besser geeignet; noch besser ist allerdings TObjectList.
Jetzt musst du entscheiden, ob TMainClass der Besitzer (owner) von sämtlichen TSubClass Objekten ist. (davon gehe ich jetzt mal aus)
Wenn du TObjectList.Create() mit dem Parameter AOwnsObjects=True ausrufst, dann brauchst du dich um die Freigabe der TSubClass Objekten nicht mehr zu kümmen.
Dennoch kannst du einzelne TSubClass-Objekte selektiv löschen.

Delphi-Quellcode:

procedure TMainClass.AccessInst(Idx: Integer);
var
   subobj : TSubClass;
begin
   subobj := TSubClass(FObjectList.Items[Idx]);
   subobj.Irgendwas := ...
end;

[marabu]

Hallo Marco,

du hast hier zuallererst mal ein syntaktisches Problem:

Delphi-Quellcode:

function TMainClass.CreateInst(): Integer;
var 
  oObj: TSubClass;
begin
  ...
  // Instanz der Liste (Klassenmember) hinzufügen
  // und Listenindex zurückgeben
  Result := oList.Add(oObj);
end;

Und dann nochmal hier:

Delphi-Quellcode:

procedure TMainClass.AccessInst(Idx: Integer);
begin
  with TSubClass(oList[Idx]) do begin
    // Auf TSubClass zugreifen
    //   --> FUNKTIONIERT NICHT!
  end;
end;

Zitat:

Nun, wahrscheinlich wird die erstellte TSubClass-Instanz beim Verlassen der CreateInst()-Funktion zerstört, weswegen später nicht mehr auf sie zugegriffen werden kann

Ganz bestimmt nicht, denn du hast das Objekt ja auf dem Heap angelegt.

Grüße vom marabu

[Robert_G]

Wenn du hier in der Sparte etwas herunterscrolls dürftest du das finden.
Les' dir das erstmal durch...


Da du es nicht gelesen hast... und shmia anscheinend auch nicht ...
Hier ein kleiner Bleisitift:

Simple SubClass mit einer Property...
Und einer exakt auf sie typisierten ObjectList.

Delphi-Quellcode:

unit uSubClass;

interface
uses
   Contnrs;

type
   TSubClass = class
   private
      fSomeProperty: Integer;
   protected
      procedure setSomeProperty(const aValue: Integer); virtual;
   public
      property SomeProperty: Integer read fSomeProperty write setSomeProperty;
   end;

{$DEFINE TYPED_OBJECT_LIST_TEMPLATE}
type
   _OBJECT_LIST_ITEM_ = TSubClass;
{$INCLUDE TypedObjectList_template.pas}
   TSubClassList = _OBJECT_LIST_;

implementation
{$INCLUDE TypedObjectList_template.pas}

{ TSubClass }

procedure TSubClass.setSomeProperty(const aValue: Integer);
begin
   fSomeProperty := aValue;
end;

end.

Und nun müssen wir nur noch die Liste benutzen. ;)
Und zwar OHNE hässliche TypeCasts und vor allem OHNE untyped Pointer! :firejump:

Delphi-Quellcode:

unit uMainClass;

interface
uses
   uSubClass;

type
   TMainClass = class
   private
      fSubClassList: TSubClassList;
   protected
      property SubClassList: TSubClassList read fSubClassList;
   public
      function CreateInstance(): Integer; virtual;
      function AccessInstance(const aIndex: Integer): TSubClass; virtual;

      constructor Create(); virtual;
      destructor  Destroy();override;
   end;

implementation

{ TMainClass }

constructor TMainClass.Create();
begin
   //sollen die Instanzen mit der Liste freigegeben werden?
   // Ja -> True / Nein -> Rate mal ;-)
   fSubClassList := TSubClassList.Create(True);

end;

function TMainClass.CreateInstance(): Integer;
var
   NewInstance          : TSubClass;
begin
   NewInstance := TSubClass.Create();
   NewInstance.SomeProperty := 1; // halt irgendwas in die Properties ;-)

   Result := SubClassList.Add(NewInstance);
end;

function TMainClass.AccessInstance(const aIndex: Integer): TSubClass;
begin
   if (aIndex >= 0) and (aIndex < SubClassList.Count) then
      Result := SubClassList[aIndex]
   else
      raise SomeJanzBöserIndexException.Create(aIndex, 0, SubClassList.Count);
end;


destructor TMainClass.Destroy();
begin
   fSubClassList.Free();
   inherited;
end;

end.

[Marphy]

Hallo zusammen,
danke erstmal für die zahlreiche Hilfe! :-D

@Robert_G:

Zitat:

Wenn du hier in der Sparte etwas herunterscrolls dürftest du das finden.
Les' dir das erstmal durch...

Tolles Teil! Aber einen Schönheitspreis würde der Code wirklich nicht gewinnen, das stimmt. Wichtiger wäre mir aber die Frage nach Performance?

Zitat:

Da du es nicht gelesen hast... und shmia anscheinend auch nicht ...

Oh doch, habe ich.

Zitat:

Und zwar OHNE hässliche TypeCasts und vor allem OHNE untyped Pointer!

Warum hässlich? :gruebel: Ich jedenfalls für meinen Teil find's elegant. :stupid:


@marabu:

Zitat:

Hallo Marco,
du hast hier zuallererst mal ein syntaktisches Problem:
[...]
Und dann nochmal hier:

Verzeih mir bitte, dass ich var eingerückt habe, schande über mich! :?
Und entschuldigen Sie, dass ich ein paar Zeichen Quellcode zuviel eingetippt habe.
Wenn du mir einen Link zu einem "Syntax-Workshop" o.ä. geben könntest, ich würde ihn lesen.

Zitat:

Ganz bestimmt nicht, denn du hast das Objekt ja auf dem Heap angelegt.

Und warum kann dann später nicht mehr auf die Klasse zugegriffen werden?


@shmia:
Danke, mit einer TObjectList werde ich es mal versuchen. Auch wenn Roberts Lösung vielleicht etwas eleganter wäre...

Gruß, Marco

[Muetze1]

Moin!

Dein grundlegendes Problem besteht darin, das du einen Zeiger auf die Instanz in die Liste abgelegt hast. Die Instanzenvariable enthält aber schon ein Zeiger auf die Instanz und somit hast du dann in der Liste einen Zeiger auf einen Zeiger der auf die Instanz zeigt. Daher nutze kein @ beim Add sondern gib direkt das Objekt/die Instanz an.

MfG
Muetze1

[Marphy]

Hallo Thomas,

Zitat:

Zitat von Muetze1

Dein grundlegendes Problem besteht darin, das du einen Zeiger auf die Instanz in die Liste abgelegt hast. Die Instanzenvariable enthält aber schon ein Zeiger auf die Instanz und somit hast du dann in der Liste einen Zeiger auf einen Zeiger der auf die Instanz zeigt. Daher nutze kein @ beim Add sondern gib direkt das Objekt/die Instanz an.

D.h. ohne @ hätte es funktioniert? :pale:

Gruß, Marco

[Waldteufel]

Hi Marco.

Vergleiche doch mal ganz genau deinen und Marabus Code... ;-)

Die Unterschiede liegen nicht nur in der Einrückung... ;-)

[marabu]

Zitat:

Zitat von Marphy

Verzeih mir bitte, dass ich var eingerückt habe, schande über mich!

Kein Problem, Marco.

Zitat:

Zitat von Marphy

Und entschuldigen Sie, dass ich ein paar Zeichen Quellcode zuviel eingetippt habe. Wenn du mir einen Link zu einem "Syntax-Workshop" o.ä. geben könntest, ich würde ihn lesen.

Genau 2 Zeichen waren es, wie ich dir im korrigierten Code zeigen wollte.

Weiterhin viel Erfolg.

marabu

[Marphy]

Hallo zusammen,
ich habe das Ganze nun mit einer TObjectList gelöst und es funktioniert tadellos. Genau so, wie ich's mir vorgestellt habe.
:dancer:

Danke an alle, die sich um meine Frage bemüht und hier gepostet haben! :-D

@Waldteufel:
Ist mit schon klar.

@marabu:
Sorry für meine etwas aggressive Antwort. Habe das "du hast ein syntaktisches Problem" im ersten Moment aber als Provokation empfunden und dementsprechend reagiert. Danke auch dir für deine Antwort(en)! :)

Grüße, Marco