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

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

调用的顺序为：

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

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
#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中

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
#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中：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
#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;
}

运行结果如下：
运行结果