In einer bestehenden Klassenstruktur musste ich eine Klasse hinzufügen, und lande jetzt im Pure Function Handler, sprich, eine virtuelle Funktion wurde nicht richtig überschrieben.
Der Compiler warnt dabei nicht - es kommt zu einem Laufzeitfehler.

Ich habe versucht das ganze möglichst simpel nachzubauen, allerdings klappt es in dem Beispiel richtig.
Meine Frage: Ist das ganze so richtig, oder ist da ein Fehler drinnen?
Leider ist das Design unnötig kompliziert, die Container Basisklasse hat einen Member mit Referenz auf die Basisklasse des Datentypen. Diese Referenz verweist dann auf einen Member der Container Realisierung.
In der Realisierung des Container Typs muss ich nun den Datentypen dem CTOR der Container Basisklasse übergeben.
Ist das so überhaupt erlaubt?

Code siehe unten:

// Datentyp: abstrakte Basis + abgeleitete Realisierung
// Basis
class BasisDatentyp
{
public:
	virtual void foo()=0;
};

// Realisierung
class AbgeleitetDatentyp : public BasisDatentyp
{
public:
	virtual void foo()
	{
		printf("AbgeleitetDatentyp::foo");
	}
};

// Container: Basis + abgeleitete Realisierung
// Basis
class BasisContainer
{
public:
	BasisContainer(BasisDatentyp& arg):m_Datentyp(arg){}
	virtual void CallFoo(){m_Datentyp.foo();}

private:
	BasisDatentyp& m_Datentyp; // Referenz
};

// Abgeleitet
class AbgeleitetContainer : public BasisContainer
{
public:
	AbgeleitetContainer():BasisContainer(m_DatentypAbgeleitet){} // ist das erlaubt???

private:
	AbgeleitetDatentyp m_DatentypAbgeleitet;

};

// main
int main(int,char**)
{

	BasisContainer *container = new AbgeleitetContainer();
	container->CallFoo();
	delete container;

	getchar();
	return 0;  
}

In einer bestehenden Klassenstruktur musste ich eine Klasse hinzufügen, und lande jetzt im Pure Function Handler, sprich, eine virtuelle Funktion wurde nicht richtig überschrieben.

Rufst du möglicherweise eine abstrakte Methode aus dem Basisklassenkonstruktor auf?

So in etwa:
#define DatenTyp_VXX DatenTyp_V7
ein paar Wochen später:
#define DatenTyp_VXX DatenTyp_V8

im Code kann man dann immer DatenTyp_VXX verwenden.

Das ist jetzt zum Problem geworden, denn wenn man denn Typ tatsächlich hinschreibt, also in der Form DatenTyp_V8, dann gibts auch keinen pure function call mehr.

Möglicherweise hilft es, das #define gegen ein typedef auszutauschen.

Tritt in der Form jedenfalls beim Microsoft C++ Compiler auf.