Vererbung mit mehrfach eingeschränktem TypParamater

[Alexander I]

Hallo,

ich möchte eine Klasse mit zweifach eingeschränktem TypParameter nach der Art TFoo<T: Interface1,Interface2> vererben.

Die Klasse0, ist die Klasse mit den zwei einschränkenden TypParametern.

An Klasse1 soll nun Klasse0 mit dem InterfaceTypParameter IKlasse1 vererbt werden.

Bekomme aber die Fehlermeldung
[dcc32 Fehler] : E2514 Typparameter 'T' muss Interface 'IKlasse2' unterstützen

Was ist falsch?


interface

type
IKlasse1 = interface;

IKlasse2 = interface;

Klasse0< T : IKlasse1, IKlasse2 > = class;

Klasse1 = class;

Klasse2 = class;



IKlasse1 = interface end;

IKlasse2 = interface end;

Klasse0< T : IKlasse1, IKlasse2 > = class(TInterfacedObject)

function Transform : T;

end;


Klasse1 = class( Klasse0< IKlasse1 > ) end; ===>> hier erfolgt die Fehlermeldung: Typparameter 'T' muss Interface 'IKlasse2' unterstützen

Klasse2 = class( Klasse0< IKlasse2 > ) end; ===>> hier erfolgt die Fehlermeldung: Typparameter 'T' muss Interface 'IKlasse1' unterstützen



implementation

end.




Gruß

Alexander

[Neutral General]

Naja die Typeinschränkungen müssen halt beide erfüllt werden.

Klasse0< T : IKlasse1, IKlasse2 > = class; =>

T muss IKlasse1 UND IKlasse2 unterstützen. Nicht ODER.

Du solltest deinen Code übrigens mit Delphi-Tags versehen. Das machts etwas übersichtlicher!

[himitsu]

Und ohne die Forward-Deklarationen sieht der Code auch gleich viel übersichtlicher aus.

Delphi-Quellcode:

interface

type
  IKlasse1 = interface end;
  IKlasse2 = interface end;

  Klasse0<T: IKlasse1, IKlasse2> = class(TInterfacedObject)
    function Transform: T;
  end;

  Klasse1 = class(Klasse0<IKlasse1>) end; 
  Klasse2 = class(Klasse0<IKlasse2>) end; 

implementation

end.

Ich hätte zwar auch ODER gedacht, aber wenn das stimmt, dann kannst du das vielleicht über eine Interfacevererbung lösen:

Delphi-Quellcode:

type
  IBasisKlasse = interface end;
  IKlasse1 = interface(IBasisKlasse) end;
  IKlasse2 = interface(IBasisKlasse) end;

  Klasse0<T: IBasisKlasse> = class(TInterfacedObject)  // oder Klasse0<T: IBasisKlasse> = class(TInterfacedObject, IBasisKlasse)
    function Transform: T;
  end;

  Klasse1 = class(Klasse0<IKlasse1>) end; 
  Klasse2 = class(Klasse0<IKlasse2>) end;

Oder du schränkst es nicht all zu sehr ein:

Delphi-Quellcode:

type
  IKlasse1 = interface end;
  IKlasse2 = interface end;

  Klasse0<T: interface> = class(TInterfacedObject)
    function Transform: T;
  end;

  Klasse1 = class(Klasse0<IKlasse1>) end; 
  Klasse2 = class(Klasse0<IKlasse2>) end;

[edit]
Ich mein natürlich IKlasse0, statt IBasisKlasse

[Alexander I]

Danke für die schnellen Antworten.

Ich hatte gedacht, gehofft das man sagen kann das für T entweder die eine oder andere IKlasse gilt.


Probiert hatte ich auch

IKlasse1 = interface(IUnknown) end;

IKlasse2 = interface(IUnknown) end;

Klasse0<T : IKlasse1, IKlasse2> = class(TInterfacedObject)

function Transform : T;

end;


Klasse1 = class( Klasse0< IKlasse1 , IKlasse2> ) end;


mit FehlerMeldung [dcc32 Fehler] E2003 Undeklarierter Bezeichner: 'Klasse0<,>'

jetzt hätte ich gedacht das beide IKlassen angenommen werden.

Gruß
Alexander

[Stevie]

Einschränkungen für Typparameter können kein "oder". Alles was du hinter dem ":" angibst, muss restlos erfüllt sein.

[himitsu]

Aso, deswegen heißt es also
E2553 Klassentypeinschränkung darf nicht mehr als einmal angegeben werden

[Alexander I]

Danke für die Tips.

Mich stört das ich eine Klasse haben muß, in der beide Interfaces auch noch implementiert werden müßen.
TKlasse = class( TInterfacedObject, IKlasse1, IKlasse2 ) .
Das wollte ich aber vermeiden.

Ich möchte in TKlasse1 nicht auf IKlasse2 zugreifen können. Was man machen könnte wäre
  TKlasse1 = class( TKlasse0<TKlasse> , IKlasse1 ) end; .
Dann hätte ich aber doppelten Code, auch wenn ich in TKlasse virtual und abstract auf die Methoden von IKlasse1 lege.


Nichts desto trotz, mein Ziel wäre gewesen in

Delphi-Quellcode:

Klasse0<T : IKlasse1, IKlasse2> = class(TInterfacedObject)
function Transform(element : T) : T;
end;

auf die Methoden und Eigenschaften von element zugriefen zu können (element.Eigenschaft1) . Aber das geht leider nicht.

Oder doch?

Gruß und Danke

Alexander

[Der schöne Günther]

Ich komme nicht ganz hinterher, was letztendlich dein Ziel ist.

Du hast zwei vollkommen verschiedene Interfaces. Eine Klasse soll jetzt entweder mit IMeinInterface1 ODER IMeinInterface2 parametrisiert werden können. Typeinschränkungen sind immer UND.

Entweder es macht Sinn und du bildest ein gemeinsames Über-Interface (welches fortan die einzige Parametrisierungs-Einschränkung ist)

Delphi-Quellcode:

type
   IMyBaseInterface = interface
      // ?
   end;

   IMyInterface1 = interface(IMyBaseInterface)
      // ?
   end;

   IMyInterface2 = interface(IMyBaseInterface)
      // ?
   end;

   TMeineGenerischeKlasse<T: IMyBaseInterface> = class

   end;

Oder es ist sicher dass es immer bei diesen beiden Interfaces bleiben wird. Dann würde ich die Klasse überhaupt nicht generisch machen sondern halt zwei verschiedene Methoden anbieten- Einmal für IMyInterface1 und einmal für IMyInterface2 .


Vielleicht liegt es an mir, aber ich persönlich habe immer große Schwierigkeiten mit vollkommen abstrakten Bezeichnern wie TKlasse1 = class( TKlasse0<TKlasse> , IKlasse1 ) end; . Kannst du vlt. ein ganz konkretes Beispiel geben? Kann ja frei erfunden sein, aber irgendwas zum "Anfassen"...

[Dejan Vu]

Zitat von Alexander I:

Mich stört das ich eine Klasse haben muß, in der beide Interfaces auch noch implementiert werden müßen.

Das geht doch gar nicht anders. Woher willst Du denn wissen, ob Du auf Property-A vom IKlasse1 zugreifen kannst, wenn deine Klasse dieses Interface gar nicht implementiert...

Mir scheint, deine OOP-Überlegungen bedürfen einer gründlicher Überarbeitung.

Zitat von Der schöne Günther:

Ich komme nicht ganz hinterher, was letztendlich dein Ziel ist.

Zitat von Sir Rufo:

...aber ich weiß nicht, ob es das ist, was du willst...

Dem schließe ich mich an.

[Alexander I]

Ich hab mal ein pdf erstellt, in dem "ersichtlich" ist wie ich mir das gedacht habe.

Es gibt zwei verschiedene Klassen: Punkte und Vektoren.

Dies erben von einer "abstrakten" BaseTransformationsKlasse die nix kann außer eine Instanz der TranslateKlasse in ihrer eigenen Methode BaseTransformations.Translate zu

instanziieren.

Die TranslateKlasse soll aber von Anfang an wissen welchem Typ sie erwarten soll, damit ich auf die Propertys zugreifen kann, nämlich element.X.

In C# gibts sowas mit where T : .... und da kann man auf Methoden und Propertys sofort zugreifen.


Gruß
Alexander