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

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()
    {
    }
};

Danke trotzdem