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>

?

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

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.

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

template<class T>
class MeineTolleNeueKlasse : Foo

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

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

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

Nennt sich in C++ Spezialisierung.

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.

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

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?

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

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

};

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

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?

Und Typsicher ist es sowieso.

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.

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++?

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

Entweder du benutzt generische Programmierung und damit Templates.
Oder du gehst rein OOP und benutzt Polymorphie

Generische Programmierung ist ebenfalls eine Art Polymorphie. Einfach eine, die zur Kompilierzeit aufgelöst wird und nicht zur Laufzeit, wie, was du wahrscheinlich unter den Namen Polymorphie verstehst, mit virtuellen Funktionen.