#include <iostream>
#include <string>
using namespace std;

// virtBasis.cpp

class Basis
{
protected:
	string str;
public:
	Basis(){ }
	Basis( string s )
		:str(s)
	{ }
};

class A : virtual public Basis
{
public:
	A( string s )
		: Basis( s )
	{ }
};

class B : virtual public Basis
{
public:
	B( string s)
		: Basis( s )
	{ }
};

class AB : public A, public B
{
public:
	AB( string s )							//
		: A ( s ), B ( s ), Basis ( s )		//	*
	{ }										//

	//AB( string s )							//
	//	: A ( s ), B ( s )						//	**
	//{ }										//

	void zeigWatt()
	{
		cout << str << endl;
	}
};

void main()
{
	AB ab("Idefix");
	ab.zeigWatt();
}

//////////////////////////
//		Ausgabe *		//
//		"Idefix"        //
//					    //
//		Ausgabe **		//
//		leerer string	//
//////////////////////////

Mfg

Dennis

Hallo.
Ich habe hier gerade eine Interessante Aufgabe gefunden.

So interessant ist sie nun auch wieder nicht.

Damit es nicht zum mehrfachen Aufruf des Basisklassen-Konstruktors kommt ist bei der virtuellen Vererbung die am meisten abgeleitete Klasse für die Initialisierung der Basisklasse zuständig.

Bei dir ist das die Klasse AB. D.h. wenn du ein Objekt von AB erzeugst werden die Basisklasseninitialisierungen von A bzw. B nicht aufgerufen. Nur AB initialisiert die Basisklasse Basis.

AB( string s )                            //
        : A ( s ), B ( s ), Basis ( s )        //    *
    { }                                        //

Hier initialisierst du die Basisklasse mit "Idefix"

//AB( string s )                            //
    //    : A ( s ), B ( s )                        //    **
    //{ }

Hier lässt du die Initialisierung der Basisklasse weg, was zum Aufruf des Standardkonstruktors der Basisklasse führt und somit zu einem leeren String.

Du kannst z.B. im Standardkonstruktor der Basisklasse str etwas zuweisen, dann siehst du es mit eigenen Augen.

Aber vielen Dank!