Ich habe mir gerade ähnliche Basisklassen gebastelt und stelle diese Beispielhaft dar:

class Elem
{
public:
	int a;
	int b;
	string str;
public:
	Elem();
	virtual Elem;

	// diverse virtuelle Methoden bzw. "normale" Methoden
};

class ElemVec : public vector<Elem>
{
	ElemVec ();
	virtual ElemVec ;

	// und auch hier diverse virtuelle Methoden bzw. "normale" Methoden die auf die Elem-MemberMethoden zugreifen bzw. auch auf die Membervariablen von Elem
};

Da die beiden Klassen für mich eine Basis sind und einiges darauf aufbaut, möchte ich nun von der Klasse Elem ableiten und zb. in der ElemList bzw. in einer Ableitung dieser weiter verwenden können:

class BigElem : public Elem
{
public:
	int c;
	int d

public:
	BigElem ();
	virtual BigElem ;

	// hier werden einige virtuelle Methoden überschrieben, neue erzeugt usw.};

so und nun komm ich zu meinem Hauptproblem, wie übergebe ich nun der Klasse ElemVec die abgeleite Klasse BigElem bzw. wie schaut die Ableitung von ElemVec aus?

class BigElemVec : public ElemVec // hmm so kann dies doch nicht gehn? da hab ich ja dann noch immer die alte ursprüngliche Basisklasse Elem als VectorElement  :confused:

Mir ist klar, dass ich einen vector von Elem* machen könnte, nur dann kann ich das Speichermanagement der STL Container nicht verwenden, was mir doch irgendwie sehr sympatisch wäre

DANKE für eure Hilfe

wenn das von mir jetzt schwachsinn war, einfach ueberlesen.

ueber template nennst du dem elemvec den typ des elements.

wenn das von mir jetzt schwachsinn war, einfach ueberlesen.

hmm naja ich weiß jetzt nicht ganz genau was du damit meinst, aber ich habe auch schon daran gedacht, dass ich ein ElemVec-Template mache, nur ich bräuchte dann auch schon im ElemVec-Tamplate zugriff auf die Members von der Klasse ELem. hmm da ich eigentlich mich in sachen templates programmierung nicht so richtig auskenne, wäre hier die Frage ob dies überhaupt möglich ist, dass man so eine Art Template macht die nur mit der Basisklasse Elem bzw. mit abgeleiteten Klassen arbeitet?
aja, falls ich nur Müll schreibe mit meinem Überlegungen, bitte nehmt es mir nicht böse, ich denke nur laut

PS: Übrigens sind die STL-Container sowieso nicht dafür entworfen worden, etwas von ihnen abzuleiten.

template<class T> class ElemVec
{ private:
    std::vector<T> MyVec;
};

Nur mischen von verschiedenen Elementen in einen Vector geht dann nicht.
Aber auch wenn das sein muß ist diese Klassenform (dann mit Smartpointern ohne Template) der Vererbung vorzuziehen.

also da ich in der zwischenzeit auch schon heftig am herumprobieren bin, bin ich auch eher für die template lösung!

was ich ja vor der erstellung meiner frage hier im forum nicht gewusst habe, dass man in templates auch auf members zugreifen kann, und somit das template "template<class T> class ElemVec" von meiner basisklasse Elem abhängig machen kann.

da ich mich gerade mit der sourcecode umstellung beschäftige, bin ich schon auf das nächste problem gestoßen, dass ich ja meine ausprogrammierten methoden im cpp nicht mehr verwenden kann. also geht nur noch die möglichkeit, sofort im header oder in der inline-datei, oder?

ps.: programmiere c++ unter linux

da ich mich gerade mit der sourcecode umstellung beschäftige, bin ich schon auf das nächste problem gestoßen, dass ich ja meine ausprogrammierten methoden im cpp nicht mehr verwenden kann. also geht nur noch die möglichkeit, sofort im header oder in der inline-datei, oder?

Ja, Template-Definitionen gehören immer in die Header (bzw. eine andere Datei, die du per #include einbindest) - das liegt daran, daß der Compiler Typ-Informationen und Quelltext an einer Stelle benötigt, um ausführbaren Code zu erzeugen.

(wenn du ein Template in eine eigene CPP-Datei packst, hat er nicht die Möglichkeit, das zusammenzubauen: beim Compilieren des Templates weiß er nicht, was er für T einsetzen muß, beim Compilieren des Anwendungscodes kennt er den Quelltext der Funktion nicht)

DANKE nochmals an alle für die tolle hilfe!

Dein Ansatz lässt sich über die Smartpointer lösen.
Aber wie schon gesagt, der Vererbung an sich ist schon unglücklich.
Ich halte eine Template klasse ElemVec für die bessere Lösung in der Form:

template<class T> class ElemVec
{ private:
    std::vector<T> MyVec;
};

Nur mischen von verschiedenen Elementen in einen Vector geht dann nicht.
Aber auch wenn das sein muß ist diese Klassenform (dann mit Smartpointern ohne Template) der Vererbung vorzuziehen.

Wobei man hier auch in Erwägung ziehen könnte private abzuleiten.

gh schrieb:

Dein Ansatz lässt sich über die Smartpointer lösen.
Aber wie schon gesagt, der Vererbung an sich ist schon unglücklich.
Ich halte eine Template klasse ElemVec für die bessere Lösung in der Form:

template<class T> class ElemVec
{ private:
    std::vector<T> MyVec;
};

Nur mischen von verschiedenen Elementen in einen Vector geht dann nicht.
Aber auch wenn das sein muß ist diese Klassenform (dann mit Smartpointern ohne Template) der Vererbung vorzuziehen.

Wobei man hier auch in Erwägung ziehen könnte private abzuleiten.

Nein.