Gibt es ne möglichkeit damit myTemplate nur die typen A,B und C annehmen kann?

emplate<class BESTTYP>
class myTemplate;

template<>
class myTemplate<A> {

};

template<>
class myTemplate<B> {

};

template<>
class myTemplate<C> {

};

Bei nem schlechten Design könntest du aber in den drei Klassen den selben Code immer haben -> nicht guut

zudem informier ich mich nach alterniven und möglichkeiten diverse dinge umzusetzen...

Auf der anderen Seite ist es aber auch so das ein Template üblicherweise eine bestimmte Schnittstelle der als Parameter übergebenen Klasse erwartet.
Daher stellt sich die Frage wieso man es unbedingt unterbinden möchte, dass man das Template auch für Klassen ausprägen kann, die diese Schnittstelle besitzen?

Um KasFs Problem zu umgehen, dass du bei der einzel-instanziierung jedesmal den ganzen Code wiederholen müsstest, wäre folgendes möglich:

template<class T>
struct Selector {
  enum {IsBESTTYPE = false};
};

template<>
struct Selector<A> {
  enum {IsBESTTYPE = true};
}; 

//usw für alle erwünschten Klassen

template<class T, bool b> class MyTemplateImp;
template<class T>
class MyTemplate : public MyTemplateImp<T, Selector<T>::IsBESTTYPE> {}; //kann man evtl auch irgendwie mit Spezialisierung regeln?

template<class T>
class MyTemplateImp<T, true> {
  //einmalig der Code
};

//Benutzung:
MyTemplate<A> mta;

MyTemplate kann jetzt nur die erwünschten Klassen als parameter erhalten, andernfalls wuerde es von MyTemplate<T, false> erben, was nicht definiert wurde.

Wenn jetzt später eine Klasse hinzugefuegt wird, die auch vom Template benutzt werden darf, einfach Selector für diese Klasse spezialisieren und IsBESTTYPE auf true setzen.

template <class T> struct U;
template <class T>
class MyTemplate : public U<T> {
  //einmalig der code
};

//Spezialisierungen von U definieren:
template<>
struct U<A> {};

//benutzung:
MyTemplate<A> mta; //ok
MyTemplate<F> mtf; //ERROR: erbt von U<F>, was nicht definiert ist.

Btw: deine KLassen A, B, C von Base abzuleiten ist zwar vielleicht nützlich, aber nicht unbedingt erforderlich. Es reicht, wenn die Klassen alle die Funktionen definieren, die vom Template benutzt werden. Dazu müssen sie die nicht erben.

Ieks, ich habs mal wieder zu kompliziert gemacht ^^
so gehts vermutlich auch:

template <class T> struct U;
template <class T>
class MyTemplate : public U<T> {
  //einmalig der code
};

//Spezialisierungen von U definieren:
template<>
struct U<A> {};

//benutzung:
MyTemplate<A> mta; //ok
MyTemplate<F> mtf; //ERROR: erbt von U<F>, was nicht definiert ist.

Btw: deine KLassen A, B, C von Base abzuleiten ist zwar vielleicht nützlich, aber nicht unbedingt erforderlich. Es reicht, wenn die Klassen alle die Funktionen definieren, die vom Template benutzt werden. Dazu müssen sie die nicht erben.

Nice