构造顺序与析构顺序

派生类构造函数执行的次序：

1. 调用基类构造函数，调用顺序按照它们 被继承时声明的顺序 （从左到右）；

2. 调用内嵌成员对象的构造函数，调用顺序按照它们在类中声明的顺序；

3. 派生类自己构造函数体中的内容。

派生类析构函数执行的次序：

派生类的析构函数的功能是在该对象消亡之前进行一些必要的清理工作，析构函数没有类型，也没有参数。

析构函数的执行顺序与构造函数相反。

---

#include <iostream>
using namespace std;
// 基类 B1
class B1
{
public:
    B1(int i)
    {
        cout<<"constructing B1 "<<i<<endl;
    }
    ~B1()
    {
        cout<<"destructing B1"<<endl;
    }
};

//基类 B2
class B2
{
public:
    B2(int j)
    {
        cout<<"constructing B2 "<<j<<endl;
    }
     ~B2()
    {
        cout<<"destructing B2"<<endl;
    }
};

//基类 B3
class B3
{
public:
    B3()
    {
        cout<<"constructing B3"<<endl;
    }
    ~B3()
    {
        cout<<"destructing B3"<<endl;
    }
};

//派生类 C， 继承B2, B1，B3（声明顺序从左至右。 B2->B1->B3）
class C: public B2, public B1, public B3
{
public:
    C(int a, int b, int c, int d):B1(a), memberB2(d), memberB1(c),B2(b)
    {
		//B1，B2的构造函数有参数，B3的构造函数无参数
      	//memberB2(d), memberB1(c)是派生类对自己的数据成员进行初始化的过程、
        //构造函数执行顺序， 基类（声明顺序）-> 内嵌成员对象的构造函数（声明顺序） -> 派生类构造函数中的内容
        C()
        {
            cout<<"constructing C"<<endl;
        }
        ~C()
        {
            cout<<"destructing C"<<endl;
        }
    }
private:
    B1 memberB1;
    B2 memberB2;
    B3 memberB3;
};

int main() 
{ 
    C obj(1,2,3,4);
    return 0; 
}

/* 输出结果 */
/*
constructing B2 2
constructing B1 1
constructing B3
constructing B1 3
constructing B2 4
constructing B3
constructing C
destructing C
destructing B3
destructing B2
destructing B1
destructing B3
destructing B1
destructing B2
*/