为什么这个菱形图案有歧义？

Question

#include <iostream>
using namespace std;

class A             { public: void eat(){ cout<<"A";} };
class B: public A   { public: void eat(){ cout<<"B";} };
class C: 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();
}

我不确定这是否被称为钻石问题，但是为什么这不起作用？

我已经为 D 给出了 eat() 的定义。因此，它不需要使用 B 或 C 的副本（因此，应该没有问题）。

当我说，a->eat()（记住eat()不是虚拟的），只有一种可能的eat()调用 A 的调用。

为什么我会收到此错误：

“A”是“D”的不明确基数

---

A *a = new D(); 对编译器到底意味着什么？

为什么

当我使用D *d = new D();时不会出现同样的问题？

Answer 1

菱形会在 D 对象中产生 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, public C { public: void eat(){ cout<<"D";} };

Answer 2

想象一个稍微不同的场景

class A             { protected: int a; public: void eat(){ a++; cout<<a;} };
class B: public A   { public: void eat(){ cout<<a;} };
class C: public A   { public: void eat(){ cout<<a;} };
class D: public B,C { public: void eat(){ cout<<"D";} };

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

如果这可行，它会增加 B 中的 a 或 C 中的 a ？这就是为什么它是暧昧的。对于两个 A 子对象（其中一个由 B 子对象包含，并且另一个由 C 子对象实现）。尝试像这样更改您的代码，它将起作用（因为它编译并打印“A”），

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

int main(){
    A *a = static_cast<B*>(new D());
      // A *a = static_cast<C*>(new D());
    a->eat();
}

这将在 BA 子对象上调用 eat分别是 和 C。

Answer 3

请注意，编译错误位于“A *a = new D();”行，而不是叫“吃饭”。

问题是，因为您使用了非虚拟继承，所以您最终会得到类 A 两次：一次通过 B，一次通过 C。例如，如果您将成员 m 添加到 A，则 D 有其中两个：B:: m 和 C::m。

有时，您确实希望在推导图中出现两次 A，在这种情况下，您始终需要指出您正在谈论哪个 A。在 D 中，您可以分别引用 B::m 和 C::m。

但有时，您确实只需要一个 A，在这种情况下，您需要使用 虚拟继承。

Answer 4

对于真正不寻常的情况，尼尔的答案实际上是错误的（至少部分是错误的）。

通过out虚拟继承，您可以在最终对象中获得A的两个独立副本。

“钻石”在最终对象中生成 A 的单个副本，并使用虚拟继承生成：

由于“钻石”意味着最终对象中只有 一个 A 副本，因此对 A 的引用不会产生歧义。如果没有虚拟继承，对 A 的引用可以引用两个不同对象中的任意一个（图中左边的一个或右边的一个）。

Answer 5

您收到的错误不是来自调用 eat() - 它来自之前的行。正是这种向上转型本身造成了歧义。正如 Neil Butterworth 指出的，D 中有两个 A 副本，而编译器不知道您想要 a 到哪一个指向.

Answer 6

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

  D
  / \
乙C
  \ /
 一个

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

    D
    /   \
 乙C
  |     |
  A  一个

继承意味着只有 1 个基 A 类的实例，而不是 2 个。

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

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

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