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

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>();

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)