虚拟继承如何解决“钻石”问题（多重继承）歧义？

Question

class A                     { public: void eat(){ cout<<"A";} }; 
class B: virtual public A   { public: void eat(){ cout<<"B";} }; 
class C: virtual public A   { public: void eat(){ cout<<"C";} }; 
class D: public         B,C { public: void eat(){ cout<<"D";} }; 

int main(){ 
    A *a = new D(); 
    a->eat(); 
} 

我理解钻石问题，上面的代码没有这个问题。

虚拟继承到底是如何解决问题的呢？

我的理解： 当我说 A *a = new D(); 时，编译器想知道 D 类型的对象是否可以分配给 A 类型的指针，但它有两条可以遵循的路径，但不能自行决定。

那么，虚拟继承如何解决这个问题（帮助编译器做出决定）？

Answer 1

你想要：（可以通过虚拟继承实现）

  A  
 / \  
B   C  
 \ /  
  D 

而不是：（没有虚拟继承会发生什么）

A   A  
|   |
B   C  
 \ /  
  D 

虚拟继承意味着只有 1 个基 A 实例 类不是 2。

您的类型 D 将有 2 个 vtable 指针（您可以在第一个图中看到它们），一个用于 B，一个用于 C 实际上继承了 A。 D 的对象大小增加了，因为它现在存储了 2 个指针；然而现在只有一个A。

因此，B::A 和 C::A 是相同的，因此来自 D 的调用不会有歧义。如果您不使用虚拟继承，您将看到上面的第二张图。然后，对 A 成员的任何调用都会变得不明确，您需要指定要采用的路径。

维基百科在这里还有另一个很好的概述和示例

Answer 2

为什么还有另一个答案？

好吧，SO 上的许多帖子和外部文章都说，钻石问题是通过创建 A 的单个实例而不是两个（D 的每个父级一个）来解决的，从而解决了歧义。然而，这并没有让我对流程有全面的了解，我最终遇到了更多问题，比如

1. 如果 B 和 C 尝试创建 A 的不同实例会怎样？ 例如，使用不同的参数调用参数化构造函数（D::D(int x, int y): C(x), B(y) {}）？ A 的哪个实例将被选择成为 D 的一部分？
2. 如果我对 B 使用非虚拟继承，但对 C 使用虚拟继承，会怎么样？在D中创建A的单个实例是否足够？
3. 从现在开始，我是否应该始终默认使用虚拟继承作为预防措施，因为它以较小的性能成本解决了可能的钻石问题，并且没有其他缺点？

如果不尝试代码示例就无法预测行为意味着不理解这个概念。下面是帮助我了解虚拟继承的内容。

Double A

首先，让我们从这段没有虚拟继承的代码开始：

#include<iostream>
using namespace std;
class A {
public:
    A()                { cout << "A::A() "; }
    A(int x) : m_x(x)  { cout << "A::A(" << x << ") "; }
    int getX() const   { return m_x; }
private:
    int m_x = 42;
};

class B : public A {
public:
    B(int x):A(x)   { cout << "B::B(" << x << ") "; }
};

class C : public A {
public:
    C(int x):A(x) { cout << "C::C(" << x << ") "; }
};

class D : public C, public B  {
public:
    D(int x, int y): C(x), B(y)   {
        cout << "D::D(" << x << ", " << y << ") "; }
};

int main()  {
    cout << "Create b(2): " << endl;
    B b(2); cout << endl << endl;

    cout << "Create c(3): " << endl;
    C c(3); cout << endl << endl;

    cout << "Create d(2,3): " << endl;
    D d(2, 3); cout << endl << endl;

    // error: request for member 'getX' is ambiguous
    //cout << "d.getX() = " << d.getX() << endl;

    // error: 'A' is an ambiguous base of 'D'
    //cout << "d.A::getX() = " << d.A::getX() << endl;

    cout << "d.B::getX() = " << d.B::getX() << endl;
    cout << "d.C::getX() = " << d.C::getX() << endl;
}

让我们看一下输出。执行 B b(2); 按预期创建 A(2)，与 C c(3); 相同：

Create b(2): 
A::A(2) B::B(2) 

Create c(3): 
A::A(3) C::C(3) 

D d (2, 3); 需要 B 和 C，它们各自创建自己的 A，所以我们有两个 < d中的code>A：

Create d(2,3): 
A::A(2) C::C(2) A::A(3) B::B(3) D::D(2, 3) 

这就是d.getX()导致编译错误的原因，因为编译器无法选择哪个A 它应该调用方法的实例。仍然可以直接调用所选父类的方法：

d.B::getX() = 3
d.C::getX() = 2

虚拟性

现在让我们添加虚拟继承。使用相同的代码示例并进行以下更改：

class B : virtual public A
...
class C : virtual public A
...
cout << "d.getX() = " << d.getX() << endl; //uncommented
cout << "d.A::getX() = " << d.A::getX() << endl; //uncommented
...

让我们跳转到 d 的创建：

Create d(2,3): 
A::A() C::C(2) B::B(3) D::D(2, 3) 

您可以看到，A 是使用默认构造函数创建的，忽略从 B 构造函数传递的参数 和 C。由于歧义性消失，对 getX() 的所有调用都会返回相同的值：

d.getX() = 42
d.A::getX() = 42
d.B::getX() = 42
d.C::getX() = 42

但是如果我们想为 A 调用参数化构造函数该怎么办？可以通过从 D 的构造函数显式调用它来完成：

D(int x, int y, int z): A(x), C(y), B(z)

通常，类只能显式使用直接父级的构造函数，但虚拟继承情况除外。发现这条规则对我来说“很有意义”，并且对理解虚拟接口有很大帮助：

代码 class B: virtual A 意味着，任何从 B 继承的类现在都负责用于自行创建 A，因为 B 不会自动执行此操作。

记住此声明后，很容易回答我遇到的所有问题

1. ： D 的创建 B 和 C 都不负责 A 的参数，完全取决于 D<仅/代码>。
2. C 会将 A 的创建委托给 D，但 B 将创建自己的 A< 实例/code> 从而使钻石问题重新出现
3. 在孙子类而不是直接子类中定义基类参数不是一个好的做法，因此当钻石问题存在且此措施不可避免时应该容忍。

Answer 3

派生类的实例存储其基类的成员。

没有虚拟继承，内存布局看起来像（注意D类中A成员的两个副本） ：

class A: [A members]
class B: public A [A members|B members]
class C: public A [A members|C members]
class D: public B, public C [A members|B members|A members|C members|D members]

使用虚拟继承，内存布局看起来像（注意D类中A成员的单个副本)：

class A: [A members]
class B: virtual public A [B members|A members]
                           |         ^
                           v         |
                         virtual table B

class C: virtual public A [C members|A members]
                           |         ^
                           v         |
                         virtual table C

class D: public B, public C [B members|C members|D members|A members]
                             |         |                   ^
                             v         v                   |
                           virtual table D ----------------|

对于每个派生类，编译器都会创建一个虚拟表，其中保存指向派生类中存储的虚拟基类成员的指针，并在派生类中添加一个指向该虚拟表的指针。

Answer 4

问题不在于编译器必须遵循的路径。问题在于该路径的端点：转换的结果。当涉及到类型转换时，路径并不重要，重要的是最终结果。

如果使用普通继承，每个路径都有自己独特的端点，这意味着强制转换的结果是不明确的，这就是问题所在。

如果使用虚拟继承，则会得到菱形层次结构：两条路径都通向同一端点。在这种情况下，选择路径的问题不再存在（或者更准确地说，不再重要），因为两条路径都会导致相同的结果。结果不再含糊不清——这才是重要的。确切的路径没有。

Answer 5

实际上，示例应该如下所示：

#include <iostream>

//THE DIAMOND PROBLEM SOLVED!!!
class A                     { public: virtual ~A(){ } virtual void eat(){ std::cout<<"EAT=>A";} }; 
class B: virtual public A   { public: virtual ~B(){ } virtual void eat(){ std::cout<<"EAT=>B";} }; 
class C: virtual public A   { public: virtual ~C(){ } virtual void eat(){ std::cout<<"EAT=>C";} }; 
class D: public         B,C { public: virtual ~D(){ } virtual void eat(){ std::cout<<"EAT=>D";} }; 

int main(int argc, char ** argv){
    A *a = new D(); 
    a->eat(); 
    delete a;
}

... 这样输出将是正确的：“EAT=>D”

虚拟继承仅解决了祖父的重复问题！
但您仍然需要将方法指定为虚拟，以便正确覆盖这些方法......