複数の仮想継承の曖昧

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 */ } 

これは:: FOO（の実装を定義します）まだBの何:: FOOを（）に動作しますか？

- 念頭に、私はC.

PSの宣言内にメソッドを定義したくない、まったくこの方法で問題をモデル化するための理由は

（COM/OLE）あらかじめ定義されています予想通り

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

2つの基本クラスで定義された同じシグネチャを持つ2つの関数に対して、別々のオーバーライドを提供することはできません。 （考えることができるように、クラス内でインラインで定義することはできません）。ベース・クラス・インターフェースの一実施各々が2つの内部クラスを構成することにより、複数の継承を避けることができ、あるいは

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

作品：これは、インラインにもかかわらず（MSVC）大丈夫です

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()は、正確にはAとBという純仮想インターフェイスが約束しているとおり、x.foo()を期待通りに呼び出します。