Generisches Alias von TFrame

[Rollo62]

Warum das nicht läuft habe ich jetzt nicht gecheckt, aber
wäre nicht ein Interface das was du suchst statt die Klasse selbst zu speichern ?

Delphi-Quellcode:

type
  TSpeziellerFrame = class(TFrame, ISpeziellerFrame)
    [...]
  End;

Rollo

[himitsu]

Zitat:

ohne class() kompilierts gar nicht

Natürlich nicht, denn du willst ja einen neuen generischen Typen definieren, also muß das auch als eigenständiger Typ (neue Klassendefinition) deklatiert werden.

"Einen" Alias für mehrere Klassen kannst du so eh nicht definieren.

Ob sowas type TKanne<xxx> = TSpeziellerFrame<xxx>; geht, also wirklich ein Alias, weiß ich jetzt nicht, oder ob man da auch type TKanne<xxx> = class(TSpeziellerFrame<xxx>); machen muß.


Dieser Alias TKanne = TSpeziellerFrame<TObjectList>; geht allerdings, aber wenn man sowas als Komponente/SubKomponente in der DFM speichern will, also auf den Formdesigner legen,
dann darf es kein Alias sein, sondern muß als neuer Typ TKanne = class(TSpeziellerFrame<TObjectList>); verpackt werden, da gültige "Bezeichner" für die Klassenverwaltung und den DFM-Reader keine < und > enthalten dürfen.

[hzzm]

Ok, vielen Dank!

So langsam gehen mir die Delphi-Generics auf den Keks, alles muss man nachher trotzdem manuell aufbroeseln. Da kann ich auch direkt alles ausschreiben, wenns immer an exakt den Ecken haengenbleibt, an denen Generics den Code vereinfachen/verallgemeinern wuerden... vielleicht habe ich da auch nur generell eine falsche Erwartungshaltung bzgl. generics, aber ich dachte das aus anderen OO-Sprachen etwas flexibler zu kennen.

[Zacherl]

Zitat von hzzm:

So langsam gehen mir die Delphi-Generics auf den Keks, alles muss man nachher trotzdem manuell aufbroeseln. Da kann ich auch direkt alles ausschreiben, wenns immer an exakt den Ecken haengenbleibt, an denen Generics den Code vereinfachen/verallgemeinern wuerden... vielleicht habe ich da auch nur generell eine falsche Erwartungshaltung bzgl. generics, aber ich dachte das aus anderen OO-Sprachen etwas flexibler zu kennen.

Ja, die Delphi Generics sind tatsächlich nur begrenzt nützlich und in keinem Fall mit anderen Sprachen vergleichbar. Das liegt primär daran, dass der Compiler deine Funktionen IMMER generiert und zwar so, dass sie theoretisch für jeden Typ lauffähig wären. Dadurch muss man sehr viel mit RTTI, "schwarzer Magie" und unsicheren Casts arbeiten. Bei anderen Sprachen wie C++ z.B. wird zur Compile-Time geschaut mit welchen Typen eine generische Funktion überhaupt aufgerufen wird und nur diese entsprechenden Varianten werden dann auch erzeugt. Im Zusammenspiel mit Template Spezialisierungen benötigt man dann absolut keine zusätzliche Laufzeitbehandlung.

Sowas wünsche ich mir für Delphi ja nach wie vor, aber ich befürchte dass wird ein Wunschtraum bleiben.

[hzzm]

Warum meckert er denn hier schon wieder:

Delphi-Quellcode:

type
  TObstKorb<T: TFrucht> = class
    procedure Essen; virtual; abstract;
  End;

  TBananenKorb = class(TObstKorb<TBanane>)
    procedure Essen; override;
  End;

[...]
begin
  AKorb := TObstKorb<TBanane>.Create;
  AKorb.Essen; // abstrakter Fehler

  AKorb := TBananenKorb.Create;
  AKorb.Essen; // funktioniert
end;

In FreePascal gaebe es ja glaube ich TBananenKorb = specialize TObstKorb<TBanane>; . Wie deklariere ich denn die Spezialisierung in Delphi ohne sie abzuleiten?

[freimatz]

Er meckert weil AKorb ein TObstKorb<TBanane> ist und dort ist Essen abstract. Ich würde da einen Fehler erwarten.

Wozu willst du eine Spezialisierung? Ich leite immer ab wenn ich es brauche.

So ganz kann ich Deine Probleme leider nicht nachvollziehen. Mich nerven die zwar auch, ab an anderen Stellen wie z.b., dass es keine contraints für Aufzählungstypen gibt.
Wie verwenden gerne Generics (gerade gesucht - an insgesammt 2168 Stellen)

[hzzm]

Zitat von freimatz:

Wozu willst du eine Spezialisierung? Ich leite immer ab wenn ich es brauche.

Wenn TObstKorb<TBanane>.Create funktionieren wuerde, koennte ich in einer generischen Funktion in Abhaengigkeit von T a la

Delphi-Quellcode:

constructor TProgrammModel<T>.Create;
begin
  Data := TObstKorb<T>.Create;
end;

die Generik weiterreichen. Das waere doch praktisch, oder?
So wie es aussieht, muss ich aber in jeder generischen Ebene dann so einen Schei*dreck wie

Delphi-Quellcode:

constructor TProgrammModel<T>.Create;
var
  AInfo: PTypeInfo;
  AInfoData: PTypeData;
  tkString: String;
begin
  AInfo := System.TypeInfo(T);
  AInfoData := GetTypeData(AInfo);
  tkString := TypInfo.GetEnumName(System.TypeInfo(T), Ord(AInfoData^.OrdType));

  if tkString = 'tkBanane' then
    AKorb := TBanenenKorb.Create
  else if tkString = 'tkApfel' then
    AKorb := TApfelKorb.Create;
end;

machen.
Erst so kann ich AKorb<T: TFrucht> wirklich generisch verwenden?! Und das in jeder generischen Hierarchie-Ebene?
JESUS CHRIST, please kill me.

Oder uebersehe ich da jetzt massiv was...

[himitsu]

Zitat von hzzm:

In FreePascal gaebe es ja glaube ich TBananenKorb = specialize TObstKorb<TBanane>; . Wie deklariere ich denn die Spezialisierung in Delphi ohne sie abzuleiten?

Keine Ahnung was das specialize in FP sein soll.

Ist das sowas wie type?

Delphi-Quellcode:

type 
  TAbc = TXyz;  // Alias
  TAbc = type TXyz;  // neuer Typ / eigene RTTI <<<<<<<<

  TAbc = class(TXyz);  // Ableitung/Vererbung

[Stevie]

Zitat von himitsu:

Zitat von hzzm:

In FreePascal gaebe es ja glaube ich TBananenKorb = specialize TObstKorb<TBanane>; . Wie deklariere ich denn die Spezialisierung in Delphi ohne sie abzuleiten?

Keine Ahnung was das specialize in FP sein soll.

Specialize ist die "pascalishe" Syntax für Generics, die sich die FPC devs ausgedacht haben - einfach mal in die Doku schauen: http://wiki.freepascal.org/Generics

Hat aber kaum mit dem Problem hier zu tun, dass abhängig von einem Typen von T eine abstrakte Methode plötzlich was ausführen könnte. Polymorphie hat in dem Zusammenhang nix mit Generics zu tun.

Generics sind prinzipiell dafür da, ebend unabhängig vom Typen einen Algorithmus auszuführen und nicht kontextuell etwas anderes (wenn T Banane ist, das, wenn es es Apfel ist, etwas anderes).

Allerdings kann man sofern man eh schon einen constaint (TProgrammModel<T: TFrucht> ) hat mit einfachen Mitteln prüfen:

Delphi-Quellcode:

constructor TProgrammModel<T>.Create;
begin
  if TypeInfo(T) = TypeInfo(TBanane) then
    fKorb := TKorb<T>(TBananenKorb.Create)
  else if TypeInfo(T) = TypeInfo(TApfel) then
    fKorb := TKorb<T>(TApfelKorb.Create);
end;