template nur mit bestimmten Typen definieren?

BorisDieKlinge

class Base{
//ABSTRACT
};

class A: public Base{
};

class B: public Base{

};
class C: public Base{

};

template<class BESTTYP>
class myTemplate {

};

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

Hi,

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

Wenn du doch ehe nur diese drei Klassen instanzieren lassen willst, wieso machst du überhaupt nen Template draus und benutzt nicht einfach nur die Klassen A,B und C ?

TomasRiker

Du könntest auch im Template ein Static Assert machen, um sicherzustellen, dass T nur A, B oder C sein kann. Ansonsten gibt's dann einen Compilerfehler.

Warum hab ich bei BorisD.K. so oft den Eindruck, dass das ein total wirres Design ist?

BorisDieKlinge

naja , ist alles nich so trivial....

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

vlt solltest du dir mal design patters anschauen. dieses head first buch soll ja ganz gut sein, ich habs aber nicht gelesen, sondern nur die sachen bei wikipedia usw. angeschaut.

Hatte auch mal überlegt, dass eine solche Typbegrenzung ganz nett wäre...

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?

pumuckl

Wirklich unterbinden kannst du die Instanziierung des Templates mit anderen Klassen so eh nicht.

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.

pumuckl

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.

pumuckl schrieb:

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