ich will eine Templateklasse erstellen, die von einer andren Templateklasse erbt und diese Spezialisieren mit wiederrum einer Templateklasse.

//Basisklasse
template<class T>class A
{
public:
	A() { arr=0; len=0; }
	A(const T& val) {
	}
	virtual void Addref(const T& val) {
		//erhöhe
	}
        // noch einiges mehr
protected:
	T** arr;
	unsigned int len;
};

//Hier die Klasse auf die Spezialisiert werden soll, die übrigens auch von
//A abgeleitet wird
template<class T> class B : public A<T>
{
public:
	B():A() { }
	explicit B(const T& val):A(val) { }
        //noch einiges mehr
};

//Jetzt die Spezialisirte Klasse
//Es soll nur der spezialisierter Typ funktionieren, sonst Fehler
template<class T>class C:public A<T>
{
};

template<class T>class C<B<T> >:public A<B<T> >
{
public:
	C(const bool& sort=false):A<B<T> >() { as=sort; }
	C(const B<T>& val,const bool& sort=false):A<B<T> >(val) { as=sort; }
        virtual mb Sort(const bool& sort=as) { //Sortiert }
        //noch andres Zeug
protected:
        bool as;
};

Und jetzt das eigentliche Problem:

int main() {
       C<B<unsigned int> > c1;  //Funktioniert
       B<unsigned int> b1;
       B<unsigned short> b2;
       C<B<unsigned int> > c2(b1);//Funktioniert
       C<B<unsigned int> > c3(b2);//Fehler->soll so sein
       C<B<unsigned int> > c4(55);//Funktioniert zwar, aber warum??<<Problem
//Gelöst, die 88 wird als bool interpretiert
       c4.Addref(66);//geht auch, aber nicht beabsichtigt!
//gelöst durch explicit, jetzt Fehler
};

Nunja, ist ein solcher Aufbau überhaupt machbar oder muss die ganze A Klasse quasi Spezialisieren(was mir egtl widerstrebt, da es den größen Teil des Codes ausmacht und sowieso nur Copy&Paste wär, weil C ja nur ne Erweiterung von A ist). Vielleicht ist es ja auch die Spezialisierung eines Templates, was hier Probleme bereitet.

Die Initialisierung von c4 funktioniert, weil es eine implizite Umwandlung von unsigned int nach B<unsigned int> gibt - das kannst ud beheben, indem du den entsprechenden Konstruktor explizit definierst.
Der Aufruf von c4.AddRef() funktioniert, weil C diese Methode von A geerbt hat.

Nunja B soll wie A halt sein, nur mit zusätzlich Funktionen die andere abgeleitete Klassen von A nicht haben sollten. C verhält soll wie A funktionieren mit zusätzlichen Funktionen(und auch Membern), aber nur B als Datentypen erlauben, da die Funktionionen von C auf die Funktionen von B zugreifen sollen. Naja ist in etwa ersichtlich aus den Beispiel.

Danke für die schnelle Antwort.

Nunja B soll wie A halt sein, nur mit zusätzlich Funktionen die andere abgeleitete Klassen von A nicht haben sollten. C verhält soll wie A funktionieren mit zusätzlichen Funktionen(und auch Membern), aber nur B als Datentypen erlauben, da die Funktionionen von C auf die Funktionen von B zugreifen sollen. Naja ist in etwa ersichtlich aus den Beispiel.

Kannst du das auch mal mit sinnvollen Bezeichnungen erklären? Ich hab' davon überhaupt kein Wort verstanden.