Ich brauche einen kurzen Denkanstoss für folgende Problematik. Meine Klassenhierarchie sah zu Beginn so aus:

template <class T>
class A1
{
// Typ T wird hier genutzt;
};

template <class T>
class B: public A1<T>
{
// Typ T wird auch hier verwendet.
};

Da die Klasse B von verschiedenen Klassen per template erben sollte, habe ich die folgende Umstellung gemacht:

template <class U, class T>
class B: public U
{
// Typ T wird auch hier verwendet.
};

typedef irgendwas T; 
typedef B<A1<T>, T>
typedef B<A2<T>, T>

Der template Parameter T ist dabei aber redundant. Gibt es eine Möglichkeit irgendwie das folgendes zu machen, sodass das typedef "funktioniert" und der Typ
T sowohl für A1 als auch B verwendet wird. Hab schon folgendes ausprobiert hab da aber zu wenig Erfahrung mit.

template <class U, class T>
class B: public U<T>
{
// Typ T wird auch hier verwendet.
};

typedef B<A1, T> B1;
typedef B<A2, T> B2;

Danke schön!

Dann muss U aber genau einen Templateparameter akzeptieren und darf keine weiteren Parameter, auch nicht mit Defaultwerten, haben.

Ich hatte dieses Problem an zwei Stellen, an einer ists nun gelöst, bei der anderen hat jedoch die Klasse U zwei template Parameter. Ich hab jedoch schon Ideen wie ich die Klassenhierarchie weiter (sinnvoll) anpassen kann, sodass das auch so gehen wird.

template <class T>
class A1
{
   typedef T value_type;
...
};

template <class A>
class B: public A
{
   typedef typename A::value_type T;
...
};

Das ist weniger restriktiv und verringert die Koppelung zwischen den Klassen. Es ist kein Zufall, dass genau das auch in praktisch allen Templates der Standardbiliothek gemacht wird.
Natürlich gibt es auch Fälle, in den Templatetemplateparameter angebracht sind, z.B. wenn das Template noch mit anderen Parametern instantiiert werden soll. Aber sogar dann gibt es ggf. noch Alternativen, man denke etwa an allocator::rebind.