Array mit Instanzen von Objekten füllen?

[Nonsense]

Hallo Community,

kann ich ein Array mit Instanzen von Objekten (Klassen) füllen?

Beispiel, ich habe 2 Klassen:

Delphi-Quellcode:

TOberKlasse = class
private
{ ... }
public
{ ... }
end;

TUnterklasse = class(TOberKlasse)
private
{ ... }
public
{ ... }
end;

Kann ich jetzt ein Array erstellen, z.B. ein

Delphi-Quellcode:

MyArray : array of TOberKlasse;

Und es dann mit Instanzen der Unterklasse (!) füllen? Welche Alternativen gibt es?

Danke im Voraus.

GReetings

[jbg]

Also wenn ich etwas nicht weiß, dann mache ich mir ein neues, leeres Projekt auf, und teste das.

Zitat:

Welche Alternativen gibt es?

Da gäbe es noch TObjectList, dass als Items aber TObject hat, und du somit immer Typecasten musst (außer du leitest die Klasse ab und überschreibst die Items[] Eigenschaft). Die TObjectList hat den Vorteil, dass .Clear,.Delete,.Remove,.Free die Instanzen automatisch freigeben.

[Nonsense]

Ja, bin gerade dabei.

Mein Problem ist, dass es eine Haupt-Klasse gibt, von der 2 andere Klassen abgeleitet werden von denen wiederum jeweils 2 Klassen abgeleitet werden.

Delphi-Quellcode:

                     TCreature
                  /             \
          TGround                TAnimal
        /          \           /         \  
    TSand         TGrass     TFox        TRabbit

In diesem Array möchte ich dann die Instanzen von TSand, TGrass, TFox und TRabbit speichern (bunt gemischt) und natürlich über das Array auf die einzelnen Instanzen zugreifen.

Zusätzlich möchte ich Instanzen auch austauschen, d.h. z.B. auf MyArray[2][14], welches eine Instanz von TSand gespeichert hat, wird eine Ableger von TGrass gespeichert, d.h. ausgetauscht.

Geht das überhaupt?

[Nonsense]

Habe mal folgendes probiert, klappt irgendwie nicht.
(Incompatible types: TCreature and TClass)
Hat jemand eine Idee?

Delphi-Quellcode:

procedure TWorld.AddCreature(PosX, PosY: Integer; CreatureClass: TClass);
begin
  FWorldArray[PosX][PosY] := CreatureClass;
end;

[Skiron]

wenn ich das problem richtig verstanden habe, müsst das funzen:

Delphi-Quellcode:

var
  FWorldArray[0..5][0..5] of TCreature;

//und beim Hinzufügen:
  FWorldArray[0, 0] := TFox.Create; //Oder was man halt braucht

//und im fall der zugriff:
  if FWorldArray[0, 0] is TFox then
    (FWorldArray[0, 0] as TFox).Die;

[Nonsense]

Ja, du liegst schon richtig. Mein Problem ist jetzt aber, wie ich die Instanz, bzw. den Zeiger auf die Instanz an die Prozedur übergebe. (Siehe ein Post drüber)

[Skiron]

meinst du sowas?

Delphi-Quellcode:

procedure CreateStuff(InstanceClass: TClass; var Reference);
var
  Instance: TObject;
begin
  Instance := TObject(InstaceClass.NewInstance);
  TObject(Reference) := Instance;
  try
    Instance.Create;
  except
    TObject(Reference) := nil;
    raise;
  end;
end;

//...
CreateStuff(TFox, FWorldArray[x, y]);
//...

[Nonsense]

Bist du so nett und erklärst mir das ganze mal. :angle:
Ich kann dir nämlich nicht so ganz folgen (d.h. gar net...).

Wird bei deinem Beispiel der Standard-Konstruktor aufgerufen? Habe nämlich meinen eigenen und müsste demnach auch Werte an diesen übergeben.

[jbg]

Zitat:

Zitat von Nonsense

(Incompatible types: TCreature and TClass)

Der Compiler sagt dir doch bereits was falsch ist.

Zitat:

Delphi-Quellcode:

... PosY: Integer; CreatureClass: TClass);

Warum übergibst du hier einen TClass-Parameter, wenn du doch einen TCreature-Parameter brauchst?

[Nonsense]

Ja, hab' ich ja auch schon vor Ewigkeiten geändert. Bin halt ein kleines ungeduldiges Kind.

Das ganze sieht bei mir jetzt folgender Maßen aus:
Als erstes hätten wir da die Klassen (stark vereinfacht).

Delphi-Quellcode:

  TWorld = class
  private
    FWorldArray : array[0..31, 0..31] of TCreature;
    [...]
  public
    constructor Create( [...] );
  [...]
  end;

  // ------------------------------

  TFox = class(TAnimal)
  private
  public
    constructor Create;
  end;

Dann den constructor von TWorld:

Delphi-Quellcode:

constructor TWorld.Create( [...] );
var
  i: Integer;
  j: Integer;
begin
  [...]

  for i := 0 to 31 do
    for j := 0 to 31 do
    begin
      AddCreature(TFox, FWorldArray[i, j]);
    end;
end;

Sowie die Funktion zum "füllen" des Arrays:

Delphi-Quellcode:

procedure TWorld.AddCreature(InstanceClass: TClass; var Reference);
var
  Instance: TObject; 
begin 
  Instance := TObject(InstanceClass.NewInstance);
  TObject(Reference) := Instance;
  try 
    Instance.Create; 
  except 
    TObject(Reference) := nil;
    raise; 
  end; 
end;

Mein Problem liegt jetzt darin, wie ich den Konstruktor von TWorld aufrufen muss, so dass das Array komplett mit Instanzen von TFox gefüllt wird.

Delphi-Quellcode:

procedure TFormMain.FormCreate(Sender: TObject);
var
  World: TWorld;
begin
  World := TWorld.Create(10, 10);
  World.Create(10, 10);
  [ ??? ]
end;

Hat jemand eine Idee?