Problem mit Templatespezialsierung

zwutz

ich kann mir denken, dass das Problem nicht neu hier ist, aber auch die Beiträge, die ich auf die Schnelle in der Forensuche gefunden hab, haben mich nicht unbegingt schlauer gemacht...

Ich habe eine "normale" Templateklasse (oder Klassentemplate?)

template<class T, class U>
class myClass
{
   // Standard-Zeugs

   void func1();
   void func2();
};

func1() ist dabei von einem speziellen T-Parameter abhängig, und func2() von einem U-Parameter. Der Rest ist unabhängig von T und U.

folgendes hat logischerweise nicht geholfen

template<class U>
void myClass<OtherClass, U>::func1()
{
}

template <class T>
void myClass<T, YetAnotherClass>::func2()
{
}

mittlerweile hat auch Google und SuFu bestätigt, dass das nicht geht, aber ich weiß trotzdem noch nicht, wie ich es richtig machen kann (ohne die ganze Klasse 5mal zu spezialisieren... da hätt ich gleich bei einzelnen Implementationen bleiben können)

Ich könnt jetzt zwar noch drei Stunden rumprobieren, aber erstens wollt ich vor der Mittagspause damit durch sein und zweitens fehlt mir an einem Montag Morgen die Motivation dazu
Ich bin zwar bei meiner Suche immer wieder drauf gestoßen, das ganze abzuleiten oder ein nested-struct einzubauen, aber wie genau weiß ich trotzdem nicht...

Auf ein paar Denkanstöße würd ich mich also freuen (kompletter Code muss nicht sein... bis zur Mittagspause ist noch genug Zeit ^^)

David_pb

Denkanstoß 1:

template<class T, class U>
struct myBase 
{
	// Standard-Zeugs

protected:
	~myBase() {}
};

template<class T, class U> 
class myClass : public myBase<T, U>
{ 
public:
   void func1()
   {
   }

   void func2()
   {
   }
};

template<class T>
class myClass<T, int> : public myBase<T, int>
{
public:
	void func1()
	{
	}

	void func2()
	{
	}
};

// etcpp

Denkanstoß 2:

template<class T>
struct Func1Policy 
{
	void operator()()
	{
	}
};

template<>
struct Func1Policy<int>
{
	void operator()()
	{
	}
};

template<class T, class U, class P1 = Func1Policy<T> > 
class myClass
{ 
	P1 p1;

public:
   void func1()
   {
	   p1();
   }

   void func2()
   {
   }
};

Denkanstoß 3:

template<class T, class U > 
class myClass
{ 
	template< typename T1 = T >
	struct Func1
	{
		static void call()
		{
		}
	};

	template<>
	struct Func1<int>
	{
		static void call()
		{
		}
	};

public:
    void func1()
    {
		Func1<T>::call();
    }

    void func2()
    {
    }
};

zwutz

habs jetzt mit Ableitung gelöst... Deine dritte Möglichkeit hätt mir zwar gefallen, hat mich aber vor diverse Probleme gestellt (unter anderem hat der Compiler ein nacktes template<> innerhalb eines Klassentemplates mit einem Fehler quittiert [ error: explicit specialization in non-namespace scope ])

Danke trotzdem