继承中调用构造函数/析构函数的顺序

Question

关于创建对象的一个​​小问题。假设我有这两个类：

struct A{
    A(){cout << "A() C-tor" << endl;}
    ~A(){cout << "~A() D-tor" << endl;}
};

struct B : public A{
    B(){cout << "B() C-tor" << endl;}
    ~B(){cout << "~B() D-tor" << endl;}

    A a;
};

在 main 中我创建了一个 B 的实例：

int main(){
    B b;
}

请注意，B 派生自 A 并且还具有A 类型的字段。

我正在尝试找出规则。我知道，构造对象时首先调用其父构造函数，而析构时则相反。

字段（在本例中为 A a;）怎么样？当B创建时，什么时候会调用A的构造函数？我还没有定义初始化列表，是否有某种默认列表？如果没有默认列表呢？还有关于破坏的同样问题。

Answer 1

• 构造总是从基类开始。如果有多个基类，则从最左边的基类开始构建。 （旁注：如果存在虚拟继承，那么它会被赋予更高的优先级）。
• 然后构造成员字段。它们被初始化在
  声明它们的顺序
• 最后，构造 class 本身
• 析构函数的顺序正好相反

无论初始值设定项列表如何，调用顺序将如下所示：

1. Base class A 的构造函数
2. class B 名为 a 的字段（类型为 class A）将被构造
3. 为派生的 class B > 的构造函数

Answer 2

假设没有虚拟/多重继承（这使事情变得相当复杂），那么规则很简单：

1. 分配对象内存
2. 执行基类的构造函数，以大多数派生结束
3. 执行成员初始化
4. 对象成为真正的实例 其类的
5. 执行

构造函数代码需要记住的一件重要事情是，直到第 4 步，该对象还不是其类的实例，因为它仅在构造函数开始执行后才获得此名称。这意味着，如果在成员的构造函数期间抛出异常，则不会执行该对象的析构函数，而只会销毁已经构造的部分（例如成员或基类）。这也意味着，如果在成员或基类的构造函数中调用对象的任何虚拟成员函数，则调用的实现将是基函数，而不是派生函数。
另一件需要记住的重要事情是，初始化列表中列出的成员将按照它们在类中声明的顺序构建，而不是按照它们在初始化列表中出现的顺序（幸运的是，如果您列出成员，大多数像样的编译器都会发出警告）以与类声明不同的顺序）。

另请注意，即使在构造函数代码执行期间，this 对象已经获得了其最终类（例如，相对于虚拟分派），该类的析构函数也不会被调用，除非构造函数 完成执行。只有当构造函数完成执行时，对象实例才是实例中真正的一等公民……在此之前，它只是一个“想要的实例”（尽管具有正确的类）。

销毁以完全相反的顺序发生：首先执行对象析构函数，然后它丢失其类（即从此时开始，该对象被视为基对象），然后所有成员以相反的声明顺序销毁，最后是基类销毁过程执行到最抽象的父级。至于构造函数，如果您在基类或成员析构函数中调用对象的任何虚拟成员函数（直接或间接），则执行的实现将是父实现，因为当类析构函数完成时，对象丢失了其类标题。

Answer 3

基类总是在数据成员之前构造。数据成员按照它们在类中声明的顺序构造。这个顺序与初始化列表无关。当数据成员被初始化时，它将在初始化列表中查找参数，如果不匹配则调用默认构造函数。数据成员的析构函数总是以相反的顺序调用。

Answer 4

基类构造函数总是先执行。因此，当您编写语句 B b; 时，首先调用 A 的构造函数，然后调用 B 类构造函数因此构造函数的输出将按如下顺序排列：

A() C-tor
A() C-tor
B() C-tor

Answer 5

#include<iostream>

class A
{
  public:
    A(int n=2): m_i(n)
    {
    //   std::cout<<"Base Constructed with m_i "<<m_i<<std::endl;
    }
    ~A()
    {
    // std::cout<<"Base Destructed with m_i"<<m_i<<std::endl; 
     std::cout<<m_i;
    }

  protected:
   int m_i;
};

class B: public A
{
  public:
   B(int n ): m_a1(m_i  + 1), m_a2(n)
   {
     //std::cout<<"Derived Constructed with m_i "<<m_i<<std::endl;
   }

   ~B()
   {
   //  std::cout<<"Derived Destructed with m_i"<<m_i<<std::endl; 
     std::cout<<m_i;//2
     --m_i;
   }

  private:
   A m_a1;//3
   A m_a2;//5
};

int main()
{
  { B b(5);}
  std::cout <<std::endl;
  return 0;
}

本例的答案是 2531。这里如何调用构造函数：

1. B::A(int n=2) 调用构造函数
2. B::B(5) 调用构造函数
3. B.m_A1::A(3) 调用
4. B。调用 m_A2::A(5) 调用

相同方式的析构函数：

1. 调用 B::~B()。即 m_i = 2，将 A 中的 m_i 减为 1。
2. 调用 B.m_A2::~A()。 m_i = 5
3. B.m_A1::~A() 被调用。 m_i = 3
   4 B::~A() 被调用。, m_i = 1

在此示例中，构造 m_A1 & 。 m_A2 与初始化列表顺序无关，与声明顺序无关。

Answer 6

修改后的代码的输出是：

A() C-tor
A() C-tor
B() C-tor
~B() D-tor
~A() D-tor
~A() D-tor