Klasse inkl. aller Unterklassen als Parameter übergeben

[Furtbichler]

Zitat von implementation:

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 von Furtbichler:

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

Damit es kompiliert...

[Lemmy]

Zitat von vagtler:

Zitat von Furtbichler:

[...] 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 von Nico93:

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.