3. Templates und OOP

Templates und OOP

  • S

    Hallo,

    ich fand im Web keine Antwort und erstelle hier mal einen doffen Anfänger beitrag 😃

    1.) Kann ich eine Klasse als abstract definieren? Ich beabsichtige eine Klasse als abstract zu behandeln (Basis für weitere Klassen) obwohl sie zur Zeit keine nicht implementierte virtuelle Methode besitzt.

    2.) Templates und das eigentliche Thema 😉 Ich definiere eine Klasse und setze vor der class ein Template z.B.

    template<Class T>

    So. Jetzt soll es nur möglich sein für T nur eine Klasse zu verwenden die von der Schnittstelle, Basisklasse oder abstrakten Klasse (je nach dem 😉 ) Foo abstammt bzw. bei "Basisklasse" eine Instanz von dieser ist. Was muss ich hier veränderen und wie?

    Was bewirkt

    template<Foo T>

    ?

    0
  • S

    1.) eine klasse ist abstract wenn mindestens eine methode pure virtual ist also:

    void Class::Foo() = 0;

    im gegensatz zu java wird das allerdings nicht im klassendeklarationskopf gesagt

    java:
    public abstract class Foo { }

    C++:
    class Foo { }

    ausserdem kann man von abstrakten klassen keine isntanzen (objekte) bilden

    also das hier geht NICHT mehr
    Foo b;

    zu 2.) kann ich nichts sagen

    aber soweit ich weis kannst du nicht für T nur klassen einsetzen, sodnern jeden (abstrakten) datentyp
    und das mit der vererbung ist meines wissens auch quatsch

    0
  • N

    Kommst du aus Java/C#?

    Siassei schrieb:

    1.) Kann ich eine Klasse als abstract definieren?

    Eine Klasse gilt automatisch als abstrakt, wenn sie rein virtuelle Methoden besitzt. Du kannst auch den Destruktor rein virtuell machen.

    Siassei schrieb:

    Jetzt soll es nur möglich sein für T nur eine Klasse zu verwenden die von der Schnittstelle, Basisklasse oder abstrakten Klasse (je nach dem 😉 ) Foo abstammt bzw. bei "Basisklasse" eine Instanz von dieser ist. Was muss ich hier veränderen und wie?

    Das entspricht nicht dem Konzept von Templates. Templates sind Vorlagen für Klassen, es können also alle Typen eingesetzt werden. Das, was du benötigst, ist einfache Vererbung; du sollst einfach eine Basisklasse erstellen, von der du dann ableiten kannst.[/quote]

    P.S.

    class MyClass {};

    wird nicht durch

    template <class MyClass> {};

    zum Template. Informier dich noch ein wenig mehr über Templates.

    0
  • S

    Hallo Nexus,

    danke für deinen Beitrag, aber ich glaube mein Post war zu kurz 😉

    class Foo {
/*
...
*/

virtual Foo getNext();

    Die Klasse Foo soll nun als Basisklasse dienen. Bei der Implementation von weiteren Kindklassen möchte ich nun, dass sich die getNext - Methode automatisch den Rückgabetype an die jeweilige Klasse anpasst.

    Beispiel:

    class KindVonFoo : Foo {
/*
...
*/

virtual KindVonFoo getNext();

    In Java hab ich folgende Möglichkeit mit Generics

    public abstract class Foo<T extends Foo> {

  /**
    ...
  */

  private T next;

  T getNext() { return next; }
}

public class KindVonFoo extends Foo<KindVonFoo> {
  // bla bla bla
}

    Der Rückgabetype T wird somit automatisch den von mir gewählten Typ [edit]KindVonFoo[/edit] angepasst. Das müssten doch in C++ die Templates sein, oder? Deklariere ich nun folgendes im Header

    template<class T>
class Foo
{
//
}

    kann ich für T jeden beliebigen Typ einsetzen. Ich möchte jedoch den Typ für T auf die Basisklasse selbst oder später vielleicht auch an eine andere Schnittstelle begrenzen

    Ich hoffe dass ich mich verständlich ausgedrückt habe 😉

    0
  • ?

    du willst also das template von der abstrakten klasse ableiten ?

    template<class T>
class MeineTolleNeueKlasse : Foo
    0
  • S

    Hallo helferlein,

    jeep, da ich in der abstrakten Klasse bereits ein paar Mehtoden implementiere und die abgeleitete Klasse die restlichen plus ein paar eigene hinzu fügt

    0
  • S

    @ Nexus Ich hab mir noch mal den Abschnitt zu Templates (C++ von A bis Z vom Jürgen) reingezogen und ich denke das ich auf den richtigen Weg bin 😉 Leider hat er meinen Anwendungsfall irgendwie übersprungen.

    template<class T>
// ...

template<class T, int A = 50>
// ...

    Leider finde ich hier keinen Hinweis, wie ich die Class auf eine Basisklasse oder Interface begrenzen kann 😞

    0
  • D

    Siassei schrieb:

    Leider finde ich hier keinen Hinweis, wie ich die Class auf eine Basisklasse oder Interface begrenzen kann 😞

    Nennt sich in C++ Spezialisierung.

    0
  • S

    drakon schrieb:

    Siassei schrieb:

    Leider finde ich hier keinen Hinweis, wie ich die Class auf eine Basisklasse oder Interface begrenzen kann 😞

    Nennt sich in C++ Spezialisierung.

    Schauen wir mal ob ich es kapiert habe. Da stand ich wieder mal auf dem Schlauch 😃

    template<Foo T>
class Foo {
/*
...
*/

virtual T getNext();
}

template<KindVonFoo T>
class KindVonFoo : Foo<T> {
/*
...
*/

T getEineMethode();
}

    Was gibt jetzt die geerbte Methode getNext() der Klasse KindVonFoo zurück? Eine Foo-Klasse oder wie von mir gewünscht eine KindVonFoo - Klasse.

    0
  • J

    templates auf bestimmte Typen zu beschränken geht meines Wissens erst mit Concepts im nächsten Standard.
    Und ehrlich gesagt, kann daran liegen, dass ich nebenbei fernschaue, aber ich verstehe net was du willst?
    Aber für mich hört sich das nach einem Fall für Polymorphie an, oder du verwendest ein Template und schmeißt die Basisklasse raus, wenn die Klasse die falsche Schnittstelle hat, kriegst du sowieso einen Compilerfehler.

    0
  • D

    Das ist noch nicht ganz richtig.
    Nochmal nachlesen. 😉

    Aber warum probierst du das nichtmal zu compilen. Dann siehst du ob du auf dem richtigen Weg bist. 😉

    0
  • S

    Hallo drakon,

    naja, ich möchte es ohne compilieren in Erfahrung bringen. Der Grund hierfür ist denkbar einfach. Eine automatische Typenanpassung erkennt man z.B. nur sehr schwer 😉

    Deutet deine Antwort darauf hin, dass ich entweder das Template für einen bestimmten Type setzen kann oder alle Typen zu lasse?

    0
  • D

    naja, ich möchte es ohne compilieren in Erfahrung bringen. Der Grund hierfür ist denkbar einfach. Eine automatische Typenanpassung erkennt man z.B. nur sehr schwer

    ?!
    Du kannst mal sehen, was der Compiler zu deinem Code meint. Der hilft vielfach um rein syntaktische Fehler zu erkennen. Dein Code ist einfach schon mal schlichtweg falsch. Der Compiler wird dir dann sagen, was daran falsch ist und auch in etwa warum.
    Dann kannst du nochmal nachlesen und dann wird dir irgendwann der Sinn dahinter klar.

    Wenn du dich ein wenig mehr mit Templates, Compiletime Polymorphie beschäftigst, wirst du in etwa das erreichen, was du willst.

    Ich würde dir aber empfehlen zuerst mal ein paar einfache Sachen mit Templates anzustellen. (z.B eine Vektorklasse für beliebige Typen).

    0
  • N

    Zu Templates gibts übrigens auch einen schönen Artikel: http://www.c-plusplus.net/forum/viewtopic-var-t-is-128361.html

    0
  • S

    Hallo,

    danke für den schönen Beitrag von hier 🙂 Aber irgendwie komme ich nicht weiter. Wieso ist Foo nicht definiert (gut das sehe ich noch ein) bzw. "Foo is not a type"?

    Scheinbar geht das nicht und ich kann aus keinem Dokument lesen wieso? Für eine Antwort wäre ich sehr dankbar. Und zurück zu meinen Problem "Wie kann ich in C++ Typensicher programmieren?". In Java gibt's es seit 1.5 die Generics wie im meinen Beispielcode von vorher zu sehen war. Wie realisiere ich sowas in C++?

    template<Foo T>
class Foo
{

	private:
		T *vari;

	public:
		Foo();

		~Foo();

		T& getVariRef();

};

#endif

template<Foo T>
Foo<T>::Foo()
{
}

template<Foo T>
Foo<T>::~Foo()
{
}

template<Foo T>
T& Foo<T>::getVariRef()
{
	return this->getVariRef();
}

template<FooChild T>
class FooChild : Foo<T>
{

};
    0
  • S

    Achja ich hab mich noch gar nicht über meine Umgebung geäusert 😉

    Linux KUbuntu
    gcc

    Als IDE werde ich KDevelop ein. Leider bin ich nicht so ganz mit der automatischen Codegeneration bzw. des Popups-Menü zufrieden. Da wurde ich von Java mit Netbeans gerade zu verwöhnt 😉 Das ist wohl in C++ etwas ... 😃

    Die Fragen aus meinen letzten Post sind nach wie vor offen 😉

    0
  • J

    template<Foo T>
    das ist nicht was du denkst.
    Du übergibst hier keinen Typ.
    Typübergabe geht nur mit class oder typename.

    0
  • V

    Was soll eigentlich der Sinn dahinter sein ein template zu machen und es dann auf GENAU einen Typen festzunageln?

    0
  • S

    void* schrieb:

    Was soll eigentlich der Sinn dahinter sein ein template zu machen und es dann auf GENAU einen Typen festzunageln?

    Einen Type und alle Kindklassen von diesem Typ.
    Der Sinn? Typensicheres programmieren. Bei der Kindklasse sollte sich der Typ T automatisch nach FooChild wandeln -> erstelle ich eine Instanz der FooChild Klasse so gibt mir FooChild->getVariRef() automatisch FooChild zurück. Vielleicht nicht das beste Beispiel 😃 In Java und C# ohne Probleme möglich in C++ komme ich nicht drauf.

    Kennt das hier keiner? 😞

    0
  • J

    Ich verstehe immer noch nicht warum du keine Polymorphie verwendest, wenn dir das so wichtig ist.

    Und Typsicher ist es sowieso.

    0
Anmelden zum Antworten