den template-typ für eine template methode durch mehrere klassen durchschleifen.

taff

da es sehr häufig vorkommt, wenn man von einer basis-klasse ableitet, dass man dann andere klassen auch noch überschreiben muss, möchte ich mir hier irgendwie abhelfen.
mir ist klar, wenn ich das unten stehende beispiel in eine template-klasse umwandle, dass man dies rasch lösen kann, jedoch möchte ich das nicht, weil dies bei div. verschachtelten ableitungen wieder zu einem problem werden könnte bzw. ich nicht dann wieder eine template-klasse erzeugen möchte.

hier mal das beispiel, welches sicher Syntaktisch falsch ist, jedoch meine absicht erklären soll:

class ElemClass
{

	public:
		std::string elemName;
	public:
		ElemClass() {}
		virtual ~ElemClass() {}

//	weitere virtuelle methoden
};

class ElemCreator
{
	protected:
		typename elem_;
	public:
		ElemCreator(typename elem=Elem) : elem_(elem) {}
		virtual ~ElemCreator(){}

		ElemClass CreateElem() {return new elem_;}
};

class MyClass
{
	protected:
		ElemCreator elemCreator_;
	public:	
		ElemCreator(typename elem=Elem) : elemCreator_(elem){}
		virtual ~ElemCreator(){}

};

nun möchte ich ich ElemClass erweitern. damit ich aber nicht auch noch ElemCreator überschreiben muss, meine typnename members.

class ElemClassDetail : public ElemClass
{
	public:
		int elemValue;
	public:
		ElemClassDetail() {}
		virtual ~ElemClassDetail() {}

//	weitere überschriebene virtuelle methoden

};

MyClass myclass(ElemClassDetail);
myclass.elemCreator_.ElemCreator();

ich bin mir nicht sicher, ob ich mit diesem beispiel mein problem schildern konnte, jedoch geht es mir einfach darum, dass ich so weit es geht template-klassen vermeiden möchte.

DANKE
lg

Th69

Sorry, aber aus deiner Beschreibung werde ich nicht richtig schlau...

Wenn du einfach nur eine Creator-Klasse brauchst, dann sieh dir mal das Factory - Design-Pattern an (einfach mal danach suchen, hab jetzt gerade keinen Link).

Um generell Typen zu erzeugen, könntest du folgende Template-Methode deklarieren:

class ElemCreator
{
  template<typename T>
  T* Create() { return new T(); } // evtl. sogar als static deklarieren

Aufruf dann z.B. so:

ElemCreator creator;
ElemClassDetail *elem = creator.Create<ElemClassDetail>();

taff

danke für die antwort!

nein um das create an sich geht es nicht, sondern "nur" um das durchschleifen des types, welches dann beim create übergeben wird.
ich möchte nicht unbedingt aus myclass eine template klasse machen, jedoch möchte ich zb. im myclass-konstruktor angeben können welche abgeleitete klasse von Elem für das ElemCreator::CreateElem verwendet werden soll (deshalb der "memeber" typename elem_ in ElemCreator)