c++中单继承构造函数与析构函数的调用顺序

在c++的单继承中，构造函数有3个需要调用的地方

1. 基类构造函数
2. 子对象构造函数
3. 派生类本身的构造函数

调用的顺序为：

1. 调用基类构造函数，对基类数据成员初始化
2. 调用子对象构造函数，对子对象数据成员初始化
3. 调用派生类构造函数，对派生类数据成员初始化

基类和派生类的构造函数相信不用多说了，前者优先于后者，需要注意的是这里面的子对象的构造函数。
注意：在每一个类中，不管他是基类还是派生类，子对象的构造函数的调用都优先于此类本身的构造函数调用
只要搞清楚了构造函数的顺序，一但遇到了析构函数，只要把构造函数反过来看，就是析构函数的调用顺序了。
实验代码如下：

#include <iostream>
using namespace std;

class D // 实验的子对象类
{
public:
    D()
    {
        cout << "构造D" << endl;
    }
    ~D()
    {
        cout << "析构D" << endl;
    }
};

class E // 实验的子对象类
{
public:
    E()
    {
        cout << "构造E" << endl;
    }
    ~E()
    {
        cout << "析构E" << endl;
    }
};

class A
{
public:
    A()
    {
        cout<< "构造A" << endl;
    }
    ~A()
    {
        cout << "析构A" << endl;
    }
    //D d;
    //E e;
};

class B :public A
{
public:
    B()
    {
        cout<< "构造B" << endl;
    }
    ~B()
    {
        cout << "析构B" << endl;
    }
    //D d;
    //E e;
};

class C: public B
{
public:
    C()
    {
        cout << "构造C" << endl;
    }
    ~C()
    {
        cout << endl << "析构C" << endl;
    }
    D d;
    E e;
};

int main()
{
    C c;
    return 0;
}

运行结果如下：

注意：在每个类中，如果有多个子对象，那么他们构造函数的调用顺序取决于他们的声明顺序，声明越早，构造越早。如上面代码中在类C中子对象d, e的构造函数调用，因为d的声明在e之前，所以的d的构造函数先调用

现在将两个子对象放到类B中

#include <iostream>
using namespace std;

class D
{
public:
    D()
    {
        cout << "构造D" << endl;
    }
    ~D()
    {
        cout << "析构D" << endl;
    }
};

class E
{
public:
    E()
    {
        cout << "构造E" << endl;
    }
    ~E()
    {
        cout << "析构E" << endl;
    }
};

class A
{
public:
    A()
    {
        cout<< "构造A" << endl;
    }
    ~A()
    {
        cout << "析构A" << endl;
    }
    //D d;
    //E e;
};

class B :public A
{
public:
    B()
    {
        cout<< "构造B" << endl;
    }
    ~B()
    {
        cout << "析构B" << endl;
    }
    D d;
    E e;
};

class C: public B
{
public:
    C()
    {
        cout << "构造C" << endl;
    }
    ~C()
    {
        cout << endl << "析构C" << endl;
    }
    //D d;
    //E e;
};

int main()
{
    C c;
    return 0;
}

运行结果如下：

下面将子对象放到类A中：

#include <iostream>
using namespace std;

class D
{
public:
    D()
    {
        cout << "构造D" << endl;
    }
    ~D()
    {
        cout << "析构D" << endl;
    }
};

class E
{
public:
    E()
    {
        cout << "构造E" << endl;
    }
    ~E()
    {
        cout << "析构E" << endl;
    }
};

class A
{
public:
    A()
    {
        cout<< "构造A" << endl;
    }
    ~A()
    {
        cout << "析构A" << endl;
    }
    D d;
    E e;
};

class B :public A
{
public:
    B()
    {
        cout<< "构造B" << endl;
    }
    ~B()
    {
        cout << "析构B" << endl;
    }
    //D d;
    //E e;
};

class C: public B
{
public:
    C()
    {
        cout << "构造C" << endl;
    }
    ~C()
    {
        cout << endl << "析构C" << endl;
    }
    //D d;
    //E e;
};

int main()
{
    C c;
    return 0;
}

运行结果如下：