Dominante Angelegenheit :D

#include <iostream>

using namespace std;

class type_a
{
public:
    virtual void do_it() = 0;
};

class type_b : virtual public type_a
{
};

class type_c : virtual public type_a
{
public:
    virtual void do_it()
    {
        wcout << L"erledigt." << endl;
    }
};

class type_d : public type_b,
               public type_c
{
};

int main()
{
    type_d obj;
    obj.do_it();
    return 0;
}

Compiler schrieb:

warning C4250: 'type_d' : inherits 'type_c::type_c::do_it' via dominance

Was bedeutet das für mich und wie löse ich dieses Problem?

David_pb

msdn schrieb:

Two or more members have the same name. The one in class2 is inherited because it is a base class for the other classes that contained this member.

Ja das hab ich auch grad gelesen. Aber wie beheb ich das Problem. Es scheint ja relativ häufig vorzukommen wenn man Multiple-Inheritance verwendet.

David_pb

do_it() auch in type_d überschreiben!

Lol. Dabei wollte ich doch Multiple-Inheritance verwenden um genau sowas zu verhindern. Na dann... Danke.

Simon2

Hi,

ich glaube nicht, dass das unbedingt etwas mit "multiple inheritance" zu tun hat, sondern eher mit "viel Vererbung" ... das kann also ebensogut mit "tiefen" Hierarchien kommen.

Wie Du das behebst ? Ganz einfach: Sinnvolles Design !

Wenn Du von einer Klasse erbst, die "do_it()" kann, dann sehe ich eigentlich keinen Grund, warum Du Deiner Klasse ein eigenes "do_it()" verpassen solltest .. höchstens durch Überschreiben einer virtuellen Funktion (und da tritt das Problem eben nicht auf).
Eigentlich sehe ich das höchstens mit privaten "Hilfsfunktionen" in den Basisklassen ... aber auch auch gilt mit gutem Grund: Implementation gehört in "Blattklassen".

Gruß,

Simon2.

David_pb

Du solltest übrigens ganz dringend einen virtuellen Destruktor in type_a haben! Diese Diamantenvererbung ist ohnehin immer eine recht gefährliche Angelegenheit.

David_pb schrieb:

Du solltest übrigens ganz dringend einen virtuellen Destruktor in type_a haben!

Habe ich bereits. Der Code den ich gepostet habe ist natürlich eine künstliche Vereinfachung.

Dominus schrieb:

#include <iostream>

using namespace std;

class type_a
{
public:
    virtual void do_it() = 0;
};

class type_b : virtual public type_a
{
};

class type_c : virtual public type_a
{
public:
    virtual void do_it()
    {
        wcout << L"erledigt." << endl;
    }
};

class type_d : public type_b,
               public type_c
{
};

int main()
{
    type_d obj;
    obj.do_it();
    return 0;
}

Wenn du willst, das type_b von type_a erben soll, aber denoch nicht die Methode do_it() haben soll, dann wäre folgendes besser:

class type_a_Real
{
public:

};

class type_a : public type_a_Real
{
public:
    virtual void do_it() = 0;
};

class type_b : virtual public type_a_Real
{
};

class type_c : virtual public type_a
{
public:
    virtual void do_it()
    {
        wcout << L"erledigt." << endl;
    }
};