Switch_Algorithm<double> o_alg;
Basis_Klasse<double>* alg_ptr  = o_alg.Get_Algorithm(level);

template <class T>	Basis_Klasse<T>*
Switch_Algorithm<T>::Get_Algorithm(const int level)
{
	switch(level)
	{
		case 0:
			return new Klasse1<T>();
		case 1:
			return new Klasse2<T>();
		case 2:
                        reutrn new Klasse3<double>();
	}
	return NULL;
}

Leider klappt es so nicht.
Ich versuche schon seit stunden irgendwie rumzumachen, ich wollte
alle spezialisierungen angeben und nur für eine die BasisKlasse zurückgeben- das geht aber auch nicht wirklich:

template <> Basis_Klasse<double>*
Switch_Algorithm<double>::Get()
{
	return new Klasse3<double>();
}

template <> Basis_Klasse<int>*
Switch_Algorithm<int>::Get()
{
	return NULL;
}

Kann mir da jemand helfen?

...klappt es so nicht....geht aber auch nicht wirklich......
Kann mir da jemand helfen?

Mit einer Fehlerbeschreibung vielleicht.

Gruß,

Simon2.

Ich versuche es also so:

case 2:
   Klasse3<double>* a = NULL;
   Get(a);

template <> void
Switch_Algorithm<double>::Get(Basis_Klasse<double> * a)
{
	a = new Klasse3<double>();
}

// z.B int typ
template <> void
Switch_Algorithm<int>::Get(Basis_Klasse<int>* a)
{
}

die fehlermeldung lautet:

Switch_Algorithm.cpp:35: Fehler: expected initializer before »<« token
Switch_Algorithm.cpp:41: Fehler: expected initializer before »<« token

Danke

Für welche Codezeile meldet er denn den Fehler ? (Bitte jetzt nicht "Zeile 35" antworten, soviel Zeilen hat nämlich Dein Beispiel gar nicht ).

Verkürze Deinen Sourcecode doch einfach mal so, dass der Fehler noch produziert wird, aber NICHTs drinsteht, was nicht zur Sache gehört.

Gruß,

Simon2.

Leider ist das verkürzen des quellcodes nicht so ohne weiteres möglich. Also ich nehme an du möchtest ein lauffähiges programm oder?

Der Fehler kommt in diesen Zeilen:

Switch_Algorithm<double>::Get(Basis_Klasse<double>*& a)

Switch_Algorithm<int>::Get(Basis_Klasse<int>*& a)

Vermutlich kennt der Compiler an der Stelle, an der er Klasse3 braucht, diese noch nicht.

Doch die kennt er. Denn wenn ich es für allgemeine Typen schreibe funktioniert alles:

template <class T>	Basis_Klasse<T>*
Switch_Algorithm<T>::Get_Algorithm(const int level)
{
	switch(level)
	{
		case 0:
			return new Klasse1<T>();
		case 1:
			return new Klasse2<T>();
		case 2:
                        return new Klasse3<T>();
		// no default case
	}
	return NULL;
}

Was ich machen möchte ist: Klasse 3 ist eine template basierte Klasse die ja von der template-basierte Basis-Klasse erbt. Allerdings soll für den case 2: nur der typ double "gemacht" werden.

Da ja Klasse3 von der Basisklasse erbt, muss doch Klasse3 auch template-basiert sein oder?

Vielleicht gibt es auch einen anderen Weg als so wie oben?

Also ich versuche nochmal den code so zu reduzieren dass ihr mich vielleicht besser versteht:

IN DER MAIN.

Switch_Algorithm<double> o_alg;
Basis_Klasse<double>* alg_ptr  = o_alg.Get_Algorithm(level);

// oder auch so z.B:
Switch_Algorithm<int> o_alg;
Basis_Klasse<int>* alg_ptr  = o_alg.Get_Algorithm(level);

SWITCH

template <class T>
class Switch_Algorithm
{
	public:

		Basis_Klasse<T>* Get_Algorithm(const int level);

		void Get(Basis_Klasse<double>*& a);
		void Get(Basis_Klasse<int>*& a);
};

template <class T>	Basis_Klasse<T>*
Switch_Algorithm<T>::Get_Algorithm(const int level)
{
	switch(level)
	{
		case 0:
			return new Klasse1<T>();
		case 1:
			return new Klasse2<T>();
		case 2:

			Basis_Klasse<T>* a = NULL;
			Get(a); 
			return a;
	}
}

template <> void
Switch_Algorithm<double>::Get(Basis_Klasse<double>*& a)
{
	a = new Klasse3<double>();
}

template <> void
Switch_Algorithm<int>::Get(Basis_Klasse<int>*& a)
{
	a = NULL;
}

DIE BASISKLASSE:

template <class T>
class Basis_Klasse
{

	public:

		// Destructor
		virtual 	~Basis_Klasse<T>(){ }
};

UND EINMAL DIE KLASSE3 - sie ist wie auch Klasse 2 und klasse 1 gleich:

template <class T>
class Klasse2 : public Basis_Klasse<T>
{
	public:
};

....
Der Fehler kommt in diesen Zeilen:

Switch_Algorithm<double>::Get(Basis_Klasse<double>*& a)

Switch_Algorithm<int>::Get(Basis_Klasse<int>*& a)

...

Was für mich danach aussieht, als würde er da Basis_Klasse nicht kennen... (war die andere Möglichkeit - hatte eine 50/50-Chance verbockt ).

Hast Du auch schon alle templates im Header implementiert ?

Bei mir compiliert jedenfalls Folgendes problemlos (abgesehen von einer "unused variable"-Warning bzgl. alg_ptr) :

// header.h
template <typename T>
struct Basis_Klasse {
   virtual ~Basis_Klasse(){ }
};    

template <typename T>
struct Klasse1 : public Basis_Klasse<T> {
   virtual void f() {}
};    

template <typename T>
struct Klasse2 : public Basis_Klasse<T> {
   virtual void g() {}
};    

template <typename T>
struct Klasse3 : public Basis_Klasse<T> {
   virtual void h() {}
};    

template <typename T>
struct Switch_Algorithm {
        Basis_Klasse<T>* Get_Algorithm(const int level);
        void Get(Basis_Klasse<T>*& a);
};    

template <typename T>
Basis_Klasse<T>*  Switch_Algorithm<T>::Get_Algorithm(const int level){
   Basis_Klasse<T>* a = 0;
    switch(level) {
        case 0: a = new Klasse1<T>(); break;
        case 1: a = new Klasse2<T>(); break;
        case 2: Get(a); break;
    }
    return a;
}

// main.cpp
#include "header.h"

template <>
void Switch_Algorithm<int>::Get(Basis_Klasse<int>*& a) {
    a = 0;
}  
template <>
void Switch_Algorithm<double>::Get(Basis_Klasse<double>*& a) {
    a = new Klasse3<double>();
}

int main (int argc, char **argv) {
   Switch_Algorithm<int> o_alg;
   Basis_Klasse<int>* alg_ptr  = o_alg.Get_Algorithm(2);
   return 0;
}

... was nicht bedeutet, dass ich das Design gutheiße - ich finde allein schon diese "implizite Typdefinition mittels level" bedenklich.

Gruß,

Simon2.

ja alles templates sind im Header implementiert. Wie gesagt - wenn ich es als Templatebasierten Parameter T setze geht ja alles.

Wie wird denn das üblicherweise gemacht wenn man nur eine spezialisierung haben wollen würde?

Gruß

Wie mache ich es denn sonst wenn ich abhängig von einem parameter unterschiedliche Abgeleitete Klassen haben möchte?
Ich bin für andere Vorschläge immer gern zu haben!

Ich schau mal, ob ich ein Beispiel bastele...

Gruß,

Simon2.

template <class T>    
Basis_Klasse<T>*
Switch_Algorithm<T>::Get_Algorithm(const int level) { ... }

Wenn du Basis_Klasse mit einem anderen Typ parametrisieren willst, musst du eine andere Typvariable verwenden, zB. mit einer Template-Memberfunktion:

template <class T>
template <class R>
Basis_Klasse<R>*
Switch_Algorithm<T>::Get_Algorithm(const int level) {
    switch (level) {
    case 0: return new Klasse1<T>;
    case 1: return new Klasse2<T>;
    case 2: return new Klasse3<double>;
    }
}

Dann musst du R aber beim Aufruf mit angeben:

Basis_Klasse<int>* pMyObj->Get_Algorithm<int>(mylevel);

Nicht nur, dass das unschön ist, R und level hängen voneinander ab. Besser ist es, wenn deine Basis_Klasse keine Template-Klasse ist.