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

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

 
 

   
   

    
    

   
   
   
   

    
    

     
     #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）以上所有对象的析构函数以与构造函数的执行顺序相反的顺序执行。

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

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