包含对象成员的类的构造与析构顺序

首先，我们来看一段代码：

#include<iostream>
using namespace std;
 
class A
{
public:
 A()
  {
        cout << "A's constructor." << endl;
  }
   ~A()
   {
       cout << "A's destructor." << endl;
   }
};
 
class B
{
public:
 B()
 {
       cout << "B's constructor." << endl;
  }
   ~B()
   {
       cout << "B's destructor." << endl;
   }
};
 
class C
{
private:
    B bInC;
public:
    C()
 {
       cout << "C's constructor." << endl;
  }
   ~C()
   {
       cout << "C's destructor." << endl;
   }
   A aInC;
};
 
class D:public C
{
public:
    D()
 {
       cout << "D's constructor." << endl;
  }
   ~D()
   {
       cout << "D's destructor." << endl;
   }
   A aInD;
private:
   B bInD;
};
 
int main(void) {
  D d;
    return 0;
}

那么，这段程序执行后，输出什么呢？

B's constructor.
A's constructor.
C's constructor.
A's constructor.
B's constructor.
D's constructor.
D's destructor.
B's destructor.
A's destructor.
C's destructor.
A's destructor.
B's destructor.

分析如下：

（1）存在继承关系时，先执行父类的构造函数，再执行子类的构造函数；

（2）当一个类中含有对象成员时，在启动本类的构造函数之前，先分配对象空间，按对象成员的声明顺序执行他们各自的构造函数，再继续执行本类的构造函数；

（3）对于非静态的局部对象，他们的析构函数的执行顺序与构造函数相反。

在本程序中：

（1）执行main()，需要创建一个对象d，所以，需要执行D的构造函数。而D继承自C，所以先要执行C的构造函数；

（2）而在C中存在对象成员bInC和aInC，所以，在C的构造函数执行之前，先按声明顺序执行B和A的构造函数，然后执行C的构造函数；

（3）轮到构造d了，但是D中有对象成员aInD和bInD，所以，在D的构造函数执行之前，先按声明顺序执行A和B的构造函数，最后，执行D的构造函数；

（4）以上所有对象的析构函数以与构造函数的执行顺序相反的顺序执行。

最终的执行结果就不言而喻了。

学无止境，共同学习。若本文所述存在错误或不妥之处，欢迎指正~