Array mit unterschiedlichen Datentypen

[holle]

Hallo, wie kann ich das vereinfachen?

Delphi-Quellcode:

Haus1 := THausA.Create(...);
Haus2 := THausB.Create(...);
Haus3 := THausC.Create(...);
Haus4 := THausD.Create(...);
...

Haus1.Zeichnen;
Haus2.Zeichnen;
Haus3.Zeichnen;
Haus4.Zeichnen;
...

Haus1.TuerAuf;
Haus2.TuerAuf;
Haus3.TuerAuf;
Haus4.TuerAuf;
...

Haus1.TuerZu;
Haus2.TuerZu;
Haus3.TuerZu;
Haus4.TuerZu;
...

Ich würde gerne alle Häuser in ein Array packen und dann über Haus[i].Zeichen; ansprechen. Das funktioniert so allerdings nicht, da Haus1, Haus2, Haus3, ... von verschiedenen Datentypen sind. Weiß jemand, wie ich das hinbekomme?

- Marcel -

[shmia]

Wenn alle Klassen von einer gemeinsamen Basisklasse abgeleitet wurden,
und diese Basisklasse virtuelle Methoden hat ist das kein Problem.
siehe: (ab Vererbung folgende)
http://www.dsdt.info/grundlagen/sprache/

[Cöster]

Was ist denn der Unterschied zwischen den 4 Häuser-Klassen? Wahrscheinlich reicht dafür doch auch eine Klasse.

[Jibiel]

@Cöster ich nehme an, die Häuser haben verschiedene Größenverhältnisse etc., das kommt bei dem Projekt nämlich vor *das gleiche Informatikbuch hat*

[mkinzler]

Zitat von Jibiel:

@Cöster ich nehme an, die Häuser haben verschiedene Größenverhältnisse etc., das kommt bei dem Projekt nämlich vor *das gleiche Informatikbuch hat*

Man könnte dies aber trotzdem in einer Klasse abbilden.

[Jelly]

Zitat von shmia:

Wenn alle Klassen von einer gemeinsamen Basisklasse abgeleitet wurden,
und diese Basisklasse virtuelle Methoden hat ist das kein Problem.

Ausser eventuell bei

Delphi-Quellcode:

Haus1 := THausA.Create(...); 
Haus2 := THausB.Create(...); 
Haus3 := THausC.Create(...); 
Haus4 := THausD.Create(...);

Da wirds wohl nicht ohne weiteren Aufwand kürzer gehen.... Aber für den Rest ist die Erzeugung einer Basisklasse der richtige Weg:

Delphi-Quellcode:

THaus = class(TObject)
protected
   procedure Zeichnen ; virtual ; abstract ;
   procedure TuerAuf ; virtual ; abstract ;
   procedure TuerZu ; virtual ; abstract ;
end ;

THausA = class(THaus)
public
   procedure Zeichnen ; override ;
   procedure TuerAuf ; override ;
   procedure TuerZu ; override ;
end ;
 // THausB usw. analog

implementation
 
procedure THausA.Zeichnen ;
begin
    inherited Zeichnen ;
    // Deine Zeichenroutine für Haus A
end ;

// usw.

Die Häuser würd ich dann nicht in einem Array sondern TObjectList ablegen. Dann sieht dein obiger Code verkürzt so aus:

Delphi-Quellcode:

procedure AlleZeichnen ;
var
  Haeuser : TObjectList;
begin
    HausA := THausA.Create ;
    HausB := THausB.Create ;
    HausC := THausC.Create ;
    HausD := THausD.Create ;

    Haeuser := TObjectList.Create ;
    Haeuser.Add (HausA) ;
    Haeuser.Add (HausB) ;
    Haeuser.Add (HausC) ;
    Haeuser.Add (HausD) ;
    for i := 0 to Haeuser.count-1 do begin
       (Haeuser[i] as THaus).Zeichnen ;
       (Haeuser[i] as THaus).TuerAuf;
       (Haeuser[i] as THaus).TuerZu;
    end ;
end ;

[Cöster]

Zitat von Jibiel:

@Cöster ich nehme an, die Häuser haben verschiedene Größenverhältnisse etc., das kommt bei dem Projekt nämlich vor *das gleiche Informatikbuch hat*

Aber wozu wurden denn Attribute erfunden? Wenn die Häuser sich z.B. darin unterscheiden, dass die Türen unterschiedlich breit sind, übergibt man die Größe doch im constructor als Parameter und speichert das dann unter den Attributen.
Bei Zeichnen der Tür schreibt man dann nicht Rectangle(20, 20, 30, 40); sondern Rectangle(FDoor.X, FDoor.Y, FDoor.X + FDoor.Width, FDoor.Y + FDoor.Height); Dadurch spart man jede Menge Schreibarbeit und es ist später leichter, Änderungen vorzunehmen, wie z.B. ein fünftes Haus oder, wenn ein Haus auf einmal breiter ist, muss man nur den Create-Aufruf ändern und nicht an den Zeichenroutinen rumpfuschen.