多重虛擬繼承的歧義

Question

最好用一個例子來解釋一下：

struct A
{
    virtual void foo() = 0;
};


struct B
{
    virtual void foo() = 0;
};


struct C : A, B
{
    // Implementation of A::foo
    void A::foo();

    // Implementation of B::foo
    void B::foo();
};


// Define here; howto?

我知道我可以定義與類內聯的函數，但是在這種情況下不可行（大約有6個基類可以使用40多種方法實現所有功能）

-

顯然我還不夠清楚。 直接的問題是：如何定義兩個繼承的foo（）方法而不會引起歧義問題？

以下確實有效

void C::foo() { /* etc */ } 

這將定義A :: foo（）的實現，而B :: foo（）的實現是什么？ 請記住，我不想在C聲明中定義方法。

PS，完全以這種方式對問題建模的原因是預先定義的（COM / OLE）

-

這很好（MSVC），盡管是內聯的：

struct A { virtual int foo() = 0; };
struct B { virtual int foo() = 0; };

struct C : A, B
{
    int A::foo() { return 1; }
    int B::foo() { return 2; }
};


void main()
{
    C* p = new C();

    cout << ((A*) p)->foo();
    cout << ((B*) p)->foo();
}

Answer 1

您不能為在兩個基類中定義的具有相同簽名的兩個函數提供單獨的替代。 （您似乎也無法在類中內聯定義它們）。

一種可能性是引入中間基類來重命名功能：

struct ABodge : A
{
    void foo() {A_foo();}
    virtual void A_foo() = 0;
};

struct BBodge : B
{
    void foo() {B_foo();}
    virtual void B_foo() = 0;
};

struct C : ABodge, BBodge
{
    void A_foo();
    void B_foo();
};

另外，可以通過組成兩個內部類來避免多重繼承，每個內部類都實現一個基類接口：

class C
{
public:
    // Could probably be defined as `operator A&()`, etc. to look more like
    // inheritance, but I usually prefer conversions to be explicit.
    A       & asA()       {return a;}
    A const & asA() const {return a;}
    B       & asB()       {return b;}
    B const & asB() const {return b;}

private:
    // These might need back-references to the 'C' that contains them.
    struct AImpl : A {void foo();} a;
    struct BImpl : B {void foo();} b;
};

Answer 2

按預期工作：

struct A { virtual void foo() = 0; };
struct B { virtual void foo() = 0; };
struct C : A, B { virtual void foo(); };
void C::foo() { }

對於任何C x; ， static_cast<A&>(x).foo()和static_cast<B&>(x).foo()將按預期調用x.foo() ，這正是A和B的純虛擬接口所承諾的。