Templates und OOP

du willst also das template von der abstrakten klasse ableiten ?

template<class T>
class MeineTolleNeueKlasse : Foo

Siassei

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

Siassei

@ 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

drakon

Siassei schrieb:

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

Nennt sich in C++ Spezialisierung.

Siassei

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.

JustAnotherNoob

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.

drakon

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.

Siassei

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?

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

?!
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).

Nexus

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

Siassei

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>
{

};

Siassei

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

JustAnotherNoob

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

void*

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

Siassei

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?

JustAnotherNoob

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

Und Typsicher ist es sowieso.

Siassei

Ich schreibe hier mal ein Java - Beispiel. Hoffentlich könnt ihr das lesen und mir ein paar Tipps für eine C++ Umsetzung geben

interface Knoten<T> {
T getParent();
T getChild();
}

class TreeElement<E extends TreeElement, T> implements Knoten<T> {
// Irgendwelche Hilfsmethoden
public E getElement() { return this; }
}

class Blatt<T> extends TreeElement<Blatt, T> {
//
}

class Zweig<T> extends TreeElement<Zweig, T> {
//
}

So, in den Klassen Blatt und Zweig werden nun alle mit E Deklarierten Typen der TreeElement - Klasse an Blatt bzw. Zweig angepasst. TreeElement ist keine abstrakte Klasse und es kann somit auch eine Instanz hier von erstellt werden. Hier wäre der Rückgabewert E vom Typ TreeElement.

drakon

Du gehst das falsch an. Du darfst einer Sprache keinen anderen Stil aufzwingen. Löse es besser mit C++ Mitteln und Vorgehensweisen. Sonst kannst du ja Java nehmen.

Siassei

drakon schrieb:

Du gehst das falsch an. Du darfst einer Sprache keinen anderen Stil aufzwingen. Löse es besser mit C++ Mitteln und Vorgehensweisen. Sonst kannst du ja Java nehmen.

Ich habe nicht vor C++ irgend etwas auf zu zwingen Wie löse ich das in C++? Ich dachte immer das C++ objektorientierte Programmierung unterstützt, aber ausser Klassen und Vererbung hab ich da kein weiteres Konzept aus OOP gefunden.

Also, wie löse ich das in C++?

JustAnotherNoob

jetzt musst du dich aber entscheiden.
Entweder du benutzt generische Programmierung und damit Templates.
Oder du gehst rein OOP und benutzt Polymorphie, wie Java in seinen frühen Tagen.

Bei deinem Beispiel hab ich das Problem, dass ich nicht verstehe was du mit T willst.