c++ - C++中的虚拟继承被误解了

Question

我读到在虚拟继承中，构造函数被称为“从最派生的”。考虑以下代码。在我看来，这里最派生的类是 D。然后是 B 和 C，“最不派生的”是 A。那么为什么首先调用最“基本”的构造函数而不是“最派生的”呢？谢谢。

#include <iostream>
using namespace std;

struct A
{
    A()
    {
        cout << "A default constructor" << endl;
    }
};

struct B : virtual public A
{
    B() : A()
    {
        cout << "B default constructor" << endl;
    }
};

struct C : virtual public A
{
    C() : A()
    {
        cout << "C default constructor" << endl;
    }
};

struct D : public B, public C
{
    D() : B(), C()
    {
        cout << "D default constructor" << endl;
    }
};

int main()
{
    D d;
}

这是输出:

A default constructor
B default constructor
C default constructor
D default constructor

更新:

---

好的。所以考虑下面的代码。请注意，虽然 D、B 和 C 构造函数发送了 7，但打印了 10。这里实际上基类是第一个被调用的。从 D 到 B 再到 A 没有链。A() 首先被调用(实际上它是默认构造函数)。然后才调用 B 和 C 构造函数。

但我读:“从最衍生。”来源:c++ virtual inheritance

这里最派生的是 D，然后是 B 和 C，然后才是 A。那么，为什么先调用 A，甚至不考虑从它们的构造函数传递给它的参数 B、D、C？谢谢。

代码:

#include <iostream>
using namespace std;

struct A
{
    int _x;
    A()
    {
        _x = 10;
        cout << "A default constructor" << endl;
    }
    A(int x)
    {
        _x = x;
        cout << "A NOT-default constructor" << endl;
    }
};

struct B : virtual public A
{
    B(int x=7) : A(x)
    {
        cout << "B  constructor" << endl;
    }
};

struct C : virtual public A
{
    C(int x=7) : A(x)
    {
        cout << "C  constructor" << endl;
    }
};

struct D : public B, public C
{
    D(int x=7) : B(x), C(x)
    {
        cout << "D  constructor" << endl;
    }
};

int main()
{
    D d;
    cout << d._x;
}

输出:

A default constructor
B  constructor
C  constructor
D  constructor
10

Answer 1

C++ 中的构造顺序非常简单:

1. 您调用最派生的构造函数(通过初始化变量；自动存储类、静态、动态等)。
2. 该构造函数初始化所有子对象:
   • 委托(delegate)的 ctor 调用另一个 most-derived-ctor。
   • 非授权的 ctor 自己完成工作:
     1. Iff 最派生的构造函数，virtual 以左优先声明顺序为基础。 (这意味着忽略非最派生构造函数给出的虚拟基构造函数的参数)
     2. 其他直接基按左先声明顺序。
     3. 声明顺序的成员。
3. 执行者 body 运行。

由于最基本的 ctor 是唯一的虚拟基，它的主体是第一个运行的 ctor-body，由最派生的 ctor 直接调用。

一般来说，调用virtual 函数、typeid 和dynamic_cast 是安全的，尽管在基础子对象全部初始化之前不是这样:May I call a virtual function to initialize a base-class sub-object?