class base{
virtual int lustigefunktion(){return 7;}
};
class child :public base
{
virtual int lustigefunktion(){return 8;}
};

ja, ein noch dümmeres beispiel ist mir nicht eingefallen.

Ich glaube, er meinte virtuelle Klassen. Wobei es auch diese nicht gibt, sondern nur virtuelle Methoden.

Es gibt aber virtuelle Basisklassen. Und da Polymorphie in den meisten Büchern zum abwinken erklärt wird, während die virtuellen Basisklassen oft nur schnell erwähnt werden, würde mich es nicht erstaunen, wenn es um diese geht.

Virtuelle Basisklassen, aus mehreren mach eins:

class CBase
{
private:
	int m_iIndex;

public:
	CBase(int iIndex = 0) : m_iIndex(iIndex) { };
	virtual ~CBase() { };

public:
	void base_method() { std::cout << "base_method of base index: " << m_iIndex << std::endl; };
};

class CLevel : public virtual CBase // (1)
{
public:
	CLevel() : CBase(1) { };
	virtual ~CLevel() { };
};

class CTest : public virtual CBase  // (2)
{
public:
	CTest() : CBase(2) { };
	virtual ~CTest() { };
};

class CTestLevel : public CLevel, public CTest
{
public:
	CTestLevel() : CLevel(), CTest() { };
	virtual ~CTestLevel() { };
};

Dank dem virtual bei (1) und (2) ist CTestLevel nur einmal von CBase abgeleitet. Würde man das virtual weglassen, so wäre CTestLevel zweimal von CBase abgeleitet, einmal über CLevel und einmal über CTest.

Wenn man den Code oben benutzt, dann sieht das so aus:

CTestLevel TestLevel;
TestLevel.base_method(); // Gibt 0 aus. Dies kommt daher, weil der Konstruktor von CBase in CTestLevel aufgerufen wird. (-> Defaultkonstruktor).

Wenn man das virtual weglassen würde, dann würde der Compiler meckern, dass base_method nicht eindeutig definierbar ist, da es zwei davon in CTestLevel hat. Also müsste man es anders aufrufen:

CTestLevel TestLevel;
TestLevel.CLevel::base_method(); // Gibt 1 aus.
TestLevel.CTest::base_method(); // Gibt 2 aus.

Noch Fragen?

Grüssli