Alex

class Foo
{
    virtual int bar(bool foobar) = 0;
};

Alex

Der Ansatz von Java mit Schnittstellen und Klassendefinitionen hat man soweit ich weiss bewusst der Mehrfachvererbung vorgezogen, da die Mehrfachvererbung nicht ganz unproblematisch ist.

Aber lassen wir das! Er hat jetzt sein "Problem" gelöst bekommen.

class A 
{
   virtual int foo () { return 0;}
};

class B : virtual public A 
{
   virtual int foo () { return 1;}
};

class C : virtual public A
{
   virtual int foo () { return 2;}
};

class D : public B, public C
{}

int main ()
{
    D Test;
    int iWert = Test.foo ();
}

Welchen Wert hat iWert?

(Damit du mich nicht missverstehst, finde die Mehrfachvererbung sehr nützlich aber wenn man nicht genau weiss was man tut kann man da böse auf die Nase fallen.)

Das folgende kompiliert, und es sollte klar sein, was passiert!

#include <iostream>
using namespace std;

class A
{
public:
	virtual int foo () { return 0;}
};

class B : virtual public A
{
public:
   virtual int foo () { return 1;}
};

class C : virtual public A
{
public:
   virtual int foo () { return 2;}
};

class D : public B, public C
{
public:
	virtual int foo()
	{
		cout << A::foo() << endl;
		cout << B::foo() << endl;
		return C::foo();
	}
};

int main ()
{
    D Test;
    cout << Test.foo() << endl;
}

Basisinitialisierer (Aufruf des entprechenden Konstruktors) für virtuelle Basisklassen, die im Konstruktor einer darüberliegenden Klasse stehen, werden ignoriert.

Ansonsten hab ich nochmal etwas nach gelesen. Mein Beispiel ist durchaus zutreffend, wenn auch mit ungünstigen Bezeichnern und kein Laufzeitproblem.
Das Problem der Mehrfachvererbung ist hauptsächlich ein konzeptioneles (z.B. Fahrzeug mit der Funktion MaxGeschwindigkeit und davon abgeleitet Schiff und Automobil und von diesen beiden Amphibienfahrzeug.
Selbst durch das Meckern des Compilers lässt sich dieses Problem nicht nur das Überschreiben von MaxGeschwindigkeit in Amphibienfahrzeug lösen, da Amphibienfahrzeug zwei unterschiedliche Maximalgeschwindigkeiten (eine zu Land und eine im Wasser) besitzt.
Klingt sehr theoretisch ist aber bei gewachsenen Systemen durchaus ein großes Problem, da man da nicht einfach mal die Klassenstruktur umstellen kann.)

#include <iostream>
using namespace std;

class Fahrzeug
{
public:
	virtual int geschwindigkeit() const = 0;
};

class Wasserfahrzeug : public Fahrzeug
{
public:
	virtual int geschwindigkeit() const { return 10; }
};

class Landfahrzeug : public Fahrzeug
{
public:
	virtual int geschwindigkeit() const { return 50; }
};

class Amphibienfahrzeug : public Wasserfahrzeug, public Landfahrzeug
{
	bool m_istAufDemWasser;
public:
	Amphibienfahrzeug(bool istAufDemWasser = false)
		: m_istAufDemWasser(istAufDemWasser) {}

	bool istAufDemWasser() const { return m_istAufDemWasser; }
	void istAufDemWasser(bool istAufDemWasser) { m_istAufDemWasser = istAufDemWasser; }

	virtual int geschwindigkeit() const
	{
		return istAufDemWasser() ? Wasserfahrzeug::geschwindigkeit() : Landfahrzeug::geschwindigkeit();
	}
};

int main ()
{
    Amphibienfahrzeug test;
    cout << test.geschwindigkeit() << endl;
    test.istAufDemWasser(true);
    cout << test.geschwindigkeit() << endl;
    cin.get();
}

In Java gibt es keine explizite virtualisierung. In C++ ist aber virtual nichts, was man leichtfertig benutzen sollte!

#include <iostream>
using namespace std;

class Fahrzeug
{
public:
    virtual int geschwindigkeit() const = 0;
    void zeigeGeschwindigkeit() const // ist in allen Subklassen gleich!
    {
    	cout << geschwindigkeit() << endl;
    }
};

class Wasserfahrzeug : public Fahrzeug
{
public:
    virtual int geschwindigkeit() const { return 10; }
};

class Landfahrzeug : public Fahrzeug
{
public:
    virtual int geschwindigkeit() const { return 50; }
};

class Amphibienfahrzeug : public Wasserfahrzeug, public Landfahrzeug
{
    bool m_istAufDemWasser;
public:
    Amphibienfahrzeug(bool istAufDemWasser = false)
        : m_istAufDemWasser(istAufDemWasser) {}

    bool istAufDemWasser() const { return m_istAufDemWasser; }
    void istAufDemWasser(bool istAufDemWasser) { m_istAufDemWasser = istAufDemWasser; }

    virtual int geschwindigkeit() const
    {
    	if(istAufDemWasser())
			return Wasserfahrzeug::geschwindigkeit();
		return Landfahrzeug::geschwindigkeit();
    }
};

void zeigeGeschwindigkeit(const Fahrzeug &f)
{
	f.zeigeGeschwindigkeit();
}

template<typename T>
void bitteZeigeGeschwindigkeit(const T &fahrzeug)
{
	cout << fahrzeug.geschwindigkeit() << endl;
}

int main ()
{
    Amphibienfahrzeug test;
    //Fahrzeug *test2 = new Amphibienfahrzeug(); //geht nicht, weil Fahrzeug in Amphibienfahrzeug mehrdeutig ist
    //test.zeigeGeschwindigkeit(); //geht nicht wegen Mehrdeutigkeit
    //zeigeGeschwindigkeit(test); //geht nicht, weil Fahrzeug in Amphibienfahrzeug mehrdeutig ist
    bitteZeigeGeschwindigkeit(test);
    test.istAufDemWasser(true);
    //test.zeigeGeschwindigkeit(); //geht nicht wegen Mehrdeutigkeit
    bitteZeigeGeschwindigkeit(test);
    cin.get();
}

Wenn man virtual ableitet geht es aber. Scheut man sich vor dynamic_cast, um spezielle Methoden zu benutzen (hat nichts mit Mehrfachvererbung zu tun), kann man auch die Basisklasse erweitern und bei nicht unterstützten Features Ausnahmen werfen, was natürlich nicht immer Sinn macht. Bei den Fahrzeugen könnte das so aussehen:

#include <iostream>
using namespace std;

class Fahrzeug
{
public:
	virtual ~Fahrzeug(){}

	virtual bool istAufDemWasser() const = 0;
    virtual void istAufDemWasser(bool istAufDemWasser) = 0;

    virtual int geschwindigkeit() const = 0;
    void zeigeGeschwindigkeit() const { cout << geschwindigkeit() << endl; }
};

class Wasserfahrzeug : virtual public Fahrzeug
{
public:
	virtual bool istAufDemWasser() const { return true; };
    virtual void istAufDemWasser(bool istAufDemWasser)
    {
    	if(!istAufDemWasser)
			throw "Wasserfahrzeug ist auf Grund gelaufen!";
    };

    virtual int geschwindigkeit() const { return 10; }
};

class Landfahrzeug : virtual public Fahrzeug
{
public:
	virtual bool istAufDemWasser() const { return false; };
    virtual void istAufDemWasser(bool istAufDemWasser)
    {
    	if(istAufDemWasser)
			throw "Landfahrzeug ist abgesoffen!";
    };

    virtual int geschwindigkeit() const { return 50; }
};

class Amphibienfahrzeug : public Wasserfahrzeug, public Landfahrzeug
{
    bool m_istAufDemWasser;
public:
    Amphibienfahrzeug(bool istAufDemWasser = false)
        : m_istAufDemWasser(istAufDemWasser) {}

    bool istAufDemWasser() const { return m_istAufDemWasser; }
    void istAufDemWasser(bool istAufDemWasser) { m_istAufDemWasser = istAufDemWasser; }

    virtual int geschwindigkeit() const
    {
    	if(istAufDemWasser())
			return Wasserfahrzeug::geschwindigkeit();
		return Landfahrzeug::geschwindigkeit();
    }
};

void zeigeGeschwindigkeit(const Fahrzeug &f) { f.zeigeGeschwindigkeit(); }

int main ()
{
    Amphibienfahrzeug test;
    test.zeigeGeschwindigkeit();
    test.istAufDemWasser(true);
    zeigeGeschwindigkeit(test);

    Fahrzeug *test2 = new Amphibienfahrzeug();
    zeigeGeschwindigkeit(*test2);
    test2->istAufDemWasser(true);
    test2->zeigeGeschwindigkeit();
    delete test2;

    cin.get();
}

Das mit dem Typecast und dem Erweitern der Basisklasse ist so eine Sache. Man sollte nie hingehen und Wissen (Variablen/Funktionen) die zu abgeleiteten Klassen gehören in die Basisklasse stecken. Ansonsten besitzen plötzlich andere abgeleitete Klassen Funktionen oder Variablen, die keinen Sinn ergeben.

Allgemeine Lösung:

class Fahrzeug
{
public:
    virtual int GetMaxGeschwindigkeit (EMedium eMedium = EMedium::eNix) const;
};

Nicht Mehrdeutig, kann immer einen Wert zurückliefern (gegebenenfalls 0 wenn es sich in dem Medium nicht bewegen kann) und auch auf Flugzeuge, Raumschiffe und UBoote anwendbar.

Typumwandlung um Sonderfälle zu behandeln, die die Schnittstelle der Basisklasse nicht abdeckt, sollte man soweit wie möglich vermeiden. (Würde bedeuten es überall und in alle Ewigkeit berücksichtigen zu müssen. Auf die Lebenszeit eines Programms gesehen fatal, weil sich dadurch immer mehr Sonderfälle ansammeln bis sie einem über den Kopf wachsen.)

Alex