Klasse inkl. aller Unterklassen als Parameter übergeben

[Nico93]

Hallo zusammen,

leider brauche ich etwas Hilfe.

Ich habe folgende Klassen (Beispiel):

Delphi-Quellcode:

THauptklasse = class
...
end;

TUnterklasseEins = class(THauptklasse)
    Eigenschaft1: string;
    Eigenschaft2: string;
end;

TUnterklasseZwei = class(THauptklasse)
    Eigenschaft1: string;
    Eigenschaft2: string;
end;

Optimal wäre es jetzt wenn man es irgendwie schaffen könnte, eine Instanz der THauptklasse zu erzeugen und darüber auf die Unteklassen zugreifen könnte, sodass ich bei einem Aufruf einer Prozedur nur die THaupsklasse als Paramter übergeben muss und gleichzeitig die beiden Unterklassen mitübergeben habe.

Beispiel:

Delphi-Quellcode:

....
interface
...
type TTest = class
private
   procedure eins(Hauptklasse: THauptklasse);
   procedure zwei();

end;

implementation

TTest.zwei()
var
  Haupt: THauptklasse;
begin
  Haupt := THauptklasse.Create;
  //Jetzt wäre es gut wenn man irgendwie wie auf eine Eigenschaft der klasse zugreifen könnte. Beispiel:
  Haupt.TUnterklasseEins.Eigenschaft1 := ......;
  eins(Haupt);
end;

TTest.eins(Hauptklasse: THaupsklasse)
var
  test: string;
begin
  //Hier wäre es gut wenn nicht nur die THauptklasse übergeben werden würde, sondern auch die Untergeordneten Klassen und man so über das o. g. Prinzip auf dessen Eigenschaften zugreifen könnte. Beispiel:
  test := Hauptklasse.TUnterklasseEins.Eigenschaft1;
end;

Vielen Dank für die Hilfe und hoffe, dass ich es relativ verständlich erklärt habe, was mein Problem ist.

[implementation]

Wie wäre es mit sowas?

Delphi-Quellcode:

type
  TElternklasse = class;

  TKindklasse1 = class(TElternklasse)
    ...
  end;

  TKindklasse2 = class(TElternklasse)
    ...
  end;

  TElternklasse = class
  private
    FKind1: TKindklasse1;
    FKind2: TKindklasse2;
  public
    property Kind1: TKindklasse1 read FKind1;
    property Kind2: TKindklasse2 read FKind2;
  end;

[swkevin08]

Schau dir mal die Abstrakten Klassen an. Dabei sollte deine Hauptklasse(abstrakte) eine methode (in deinem beispiel "eins") beinhalten. Dann bastelst dir beliebig viele unterklassen.

jetzt übergibst du als parameter die abstrakte Klasse, rufst die abstrakte methode auf und fertisch^^

gruß

[himitsu]

Wobei die Vererbung der Kindklassen von der Hauptklasse noch etwas fragwürdig ist.

Falls die Kinder Gemeinsamkeiten haben, dann eine eigene Vorfahrklasse für die Kinder.
Ansonsten kommt man hier wohl auch ohne Vererbung aus.

Falls auch mal mehr Kindklassen möglich sind, dann diese auch verwerben, selbst wenn physisch nichts vererbt wird, außer daß es alle Kinder sind.
Und dann die Kinder in eine Liste und nicht unbedingt je in ein eigenes Property.

[Nico93]

Vielen Danke für die schnelle Hilfe.
Das wars, was ich gesucht habe.

[vagtler]

Zitat:

Zitat von Nico93 (Beitrag 1160872)

[...] eine Instanz der THauptklasse zu erzeugen und darüber auf die Unteklassen zugreifen könnte, sodass ich bei einem Aufruf einer Prozedur nur die THaupsklasse als Paramter übergeben muss und gleichzeitig die beiden Unterklassen mitübergeben habe. [...]

Ich werde den Eindruck nicht los, dass hier gedanklich (noch) keine klare Trennung zwischen Klassen und Instanzen stattgefunden hat...

[Furtbichler]

Zitat:

Zitat von implementation (Beitrag 1160874)

Wie wäre es mit sowas?

Delphi-Quellcode:

type
  TElternklasse = class; // <<--- Diese Zeile ist markiert (siehe Frage weiter unten)

  TKindklasse1 = class(TElternklasse)
    ...
  end;

  TKindklasse2 = class(TElternklasse)
    ...
  end;

  TElternklasse = class
  private
    FKind1: TKindklasse1;
    FKind2: TKindklasse2;
  public
    property Kind1: TKindklasse1 read FKind1;
    property Kind2: TKindklasse2 read FKind2;
  end;

Wozu dient die Vorwärtsdeklaration? (markierte Zeile)?

[vagtler]

Zitat:

Zitat von Furtbichler (Beitrag 1160889)

[...] Wozu dient die Vorwärtsdeklaration? (markierte Zeile)?

Damit es kompiliert... ;)

[Lemmy]

Zitat:

Zitat von vagtler (Beitrag 1160890)

Zitat:

Zitat von Furtbichler (Beitrag 1160889)

[...] Wozu dient die Vorwärtsdeklaration? (markierte Zeile)?

Damit es kompiliert... ;)

wobei es imho besser wäre, wenn so was nicht kompiliert werden könnte....

[Blup]

Ich denke hier ist einfach ein Cast angebracht:

Delphi-Quellcode:

TTest.eins(Hauptklasse: THaupsklasse)
var
  test: string;
begin
  //Hier wäre es gut wenn nicht nur die THauptklasse übergeben werden würde, sondern auch die Untergeordneten Klassen und man so über das o. g. Prinzip auf dessen Eigenschaften zugreifen könnte. Beispiel:
  if Hauptklasse is TUnterklasseEins then
    test := TUnterklasseEins(Hauptklasse).Eigenschaft1
  else if Hauptklasse is TUnterklasseZwei then
    test := TUnterklasseZwei(Hauptklasse).Eigenschaft1;
end;

Wie schon gesagt, wenn es sich im Prinzip um die selben Eigenschaften handelt, könnte man diese auch abstract in der Basisklasse deklarieren. Eine anderer Weg ist die gleichartigen Eigenschaften und Methoden zu einem Interface zusammen zu fassen und bei Bedarf abzufragen.

[himitsu]

Die Kinder sollen die Eltern kennen
und die eltern die Kinder
=
Kreisverkehr


Wobei, wenn man den Kindern einen eigenen vorfahren gönnt, da sie ja scheinbar eh nicht wirklich von ihren Eltern ihrem Verwalter abstemmen, dann braucht man sowas wirklich nicht. (Es sei denn sie müssen ihren Verwalter wirlich mit genauem Typ kennen)

[Nico93]

die Eigenschaften der Unterklassen sind nicht gleich, sondern unterschiedlich.
Beispiel:

Delphi-Quellcode:

TUnterklasse1:
    Vorname: string;
    Nachname: string;
TUnterklasse2:
    Datum: TDateTime;
    Ort: string;

Ich habe leider noch eine kurze Frage:
Wenn ich jetzt eine Instanz der THauptklasse erzeuge und diese Instanz als Parameter an eine Prozedur übergebe, wo muss ich diese dann wieder freigeben (in der Prozedur, in der die Instanz erzeugt wurde oder in der Prozedur, an die die Instanz übergeben wurde)?

[implementation]

Zitat:

Zitat von Nico93 (Beitrag 1160980)

Ich habe leider noch eine kurze Frage:
Wenn ich jetzt eine Instanz der THauptklasse erzeuge und diese Instanz als Parameter an eine Prozedur übergebe, wo muss ich diese dann wieder freigeben (in der Prozedur, in der die Instanz erzeugt wurde oder in der Prozedur, an die die Instanz übergeben wurde)?

Rein vom möglichen her: Egal.
Aber schöner und sinnvoller ist es immer, eine Instanz dort wieder freizugeben, wo sie auch erzeugt wurde.

[himitsu]

Dann lohnt sich Vererbung der Klassen erstmal nicht, da sie ja nichts gemeinsam haben, was sie erben könnten.

Delphi-Quellcode:

type
  TKindklasse1 = class
    ...
  end;

  TKindklasse2 = class
    ...
  end;

  TElternklasse = class
  private
    FKind1: TKindklasse1;
    FKind2: TKindklasse2;
  public
    property Kind1: TKindklasse1 read FKind1;
    property Kind2: TKindklasse2 read FKind2;
  end;

Oder eben so, da sie ja mit der Elternklasse absolut nichts gemeinsam haben.
Aber da die Kindklassen auch nicht wirklich was gemeinsames haben, dann doch eher Ersteres.

Delphi-Quellcode:

type
  TKindklasse = class
  end;

  TKindklasse1 = class(TKindklasse)
    ...
  end;

  TKindklasse2 = class(TKindklasse)
    ...
  end;

  TElternklasse = class
  private
    FKind1: TKindklasse1;
    FKind2: TKindklasse2;
  public
    property Kind1: TKindklasse1 read FKind1;
    property Kind2: TKindklasse2 read FKind2;
  end;

PS: Das würde eine Endlosschleife, wenn man da im Constructor der Elternklasse die Kindklassen erzeugt und dabei die Kindklassen von der Elternklasse erben,
denn dann hätten die Kinder wiederum eigene Kinder, welche ebenfalls Kinder hätten, die Kinder hätten usw.