构造函数调用顺序与组合

我有A类和B类。 C 类派生自 B 类，并以 A 类对象作为组合。http://ideone.com/JGT48M http://ideone.com/JGT48M

#include "iostream"
using namespace std;

class A {
  int i;
public:
  A(int ii) : i(ii) {
      cout << "\n Constructor of A is called \n";

  }
  ~A() {
      cout << "\n destructor  of A is called \n";
  }
  void f() const {}
};

class B {
  int i;
public:
  B(int ii) : i(ii) {
      cout << "\n Constructor of B is called \n";
  }
  ~B() {
      cout << "\n destructor  of B is called \n";
  }
  void f() const {}
};

class C : public B {
  A a;
public:
  C(int ii) : a(ii), B(ii) {
      cout << "\n Constructor of C is called \n";
  }
  ~C() {
  cout << "\n destructor  of C is called \n";
  } // Calls ~A() and ~B()
  void f() const {  // Redefinition
    a.f();
    B::f();
  }
};

int main() {
  C c(47);
} ///:~

我读过，构造函数的调用是基于它们在派生类构造函数中的调用方式。我的意思是让有一个名为 REF 的类派生自 REF_BASE1 和 REF_BASE2 然后

 REF (int ii) : REF_BASE2(ii), REF_BASE1 (ii) {

意味着将首先调用 REF_BASE2，然后调用 REF_BASE1，然后调用 REF 构造函数。 如果我们将其定义为

REF (int ii) : REF_BASE1(ii), REF_BASE2 (ii) {

意味着将首先调用 REF_BASE1，然后调用 REF_BASE2，然后调用 REF 构造函数。

然而，在我上面的程序中，我明确“错误地”指出，通过内部组合变量 A 首先初始化，然后 B 应该初始化，但编译器以正确的方式执行此操作，但未能让我知道我的错误

无论我在派生类构造函数初始化列表中指定的顺序如何，上述程序的输出都是

Constructor of B is called 

 Constructor of A is called 

 Constructor of C is called 

 destructor  of C is called 

 destructor  of A is called 

 destructor  of B is called 

我的问题是 1）为什么编译器不抱怨？或者我是对的吗？ 2）派生构造函数中的顺序是否没有严格遵循？

我从第二个问题开始：

2）派生构造函数中的顺序是否没有严格遵循？

该顺序不是出现在构造函数初始化列表中的顺序，而是基类出现在类定义中的顺序。

因此，如果您的类定义如下所示：

struct A : B, C
{
    // ...
};

然后构造函数B将在构造函数之前调用C，无论您在初始化列表中指定什么顺序A的构造函数。

C++11 标准第 12.6.2/10 段规定：

在非委托构造函数中，初始化按以下顺序进行：

— 首先，仅对于最底层派生类 (1.8) 的构造函数，虚拟基类在 它们在基类有向无环图的深度优先从左到右遍历中出现的顺序， 其中“从左到右”是派生类基说明符列表中基类的出现顺序。

— Then, 直接基类按照它们出现在基说明符列表中的声明顺序进行初始化 （无论内存初始化器的顺序如何）.

— 然后，非静态数据成员按照它们在类定义中声明的顺序进行初始化 （同样无论内存初始化器的顺序如何）。

— 最后，执行构造函数体的复合语句。

现在第一个问题：

1）为什么编译器不抱怨？

编译器may警告您构造函数初始值设定项列表中的初始化顺序与基类列表中的初始化顺序不同（GCC 使用-Wall），但不是必须的。最终，只有后者才重要。