C++构造函数执行顺序

经测试按照如下顺序：

一、先执行静态成员的构造函数，如果静态成员只是在类定义中声明了，而没有实现，是不用构造的。必须初始化后才执行其构造函数。

二、任何虚拟继承基类的构造函数按照它们被继承的顺序构造（不是初始化列表中的顺序）

三、任何非虚拟继承基类的构造函数按照它们被继承的顺序构造（不是初始化列表中的顺序）

四、任何成员对象的构造函数按照它们声明的顺序构造

五、类自己的构造函数

测试程序如下：

[cpp]  view plain copy

1. #include <iostream>  
2. #include <string>  
3. using namespace std;  
4.   
5. //抽象类A  
6. class A  
7. {  
8. public:  
9.     A()  
10.     {  
11.         cout<<"抽象类A的构造函数"<<endl;  
12.     }  
13.     //纯虚函数fun  
14.     virtual void fun1() = 0;  
15. };  
16.   
17. //抽象类B  
18. class B  
19. {  
20. public:  
21.     B()  
22.     {  
23.         cout<<"抽象类B的构造函数"<<endl;  
24.     }  
25.     //纯虚函数fun  
26.     virtual void fun2() = 0;  
27. };  
28.   
29. //普通类C  
30. class C  
31. {  
32. public:  
33.     C()  
34.     {  
35.         cout<<"类C的构造函数"<<endl;  
36.     }  
37. };  
38.   
39. //普通类D  
40. class D  
41. {  
42. public:  
43.     D()  
44.     {  
45.         cout<<"类D的构造函数"<<endl;  
46.     }  
47. };  
48.   
49. //普通类C  
50. class E  
51. {  
52. public:  
53.     E()  
54.     {  
55.         cout<<"类E的构造函数"<<endl;  
56.     }  
57. };  
58.   
59. //普通类D  
60. class F  
61. {  
62. public:  
63.     F()  
64.     {  
65.         cout<<"类F的构造函数"<<endl;  
66.     }  
67. };  
68.   
69. //普通类D  
70. class G  
71. {  
72. public:  
73.     G()  
74.     {  
75.         cout<<"类G的构造函数"<<endl;  
76.     }  
77. };  
78.   
79. //普通类D  
80. class H  
81. {  
82. public:  
83.     H()  
84.     {  
85.         cout<<"类H的构造函数"<<endl;  
86.     }  
87. };  
88. //普通类D  
89. class M  
90. {  
91. public:  
92.     M()  
93.     {  
94.         cout<<"类M的构造函数"<<endl;  
95.     }  
96. };  
97.   
98. class Test: public A,public B,virtual public C,virtual public D,public E,public F  
99. {  
100. public:  
101.     Test():B(),A(),D(),C(),F(),E()  
102.     {  
103.         cout<<"类Test的构造函数"<<endl;  
104.     }  
105.     void fun1()  
106.     {  
107.     }  
108.     void fun2()  
109.     {  
110.     }  
111. private:  
112.     G g;  
113.     static H h;  
114.     static M m;  
115. };  
116.   
117. H Test::h;  
118.   
119. int main(int argc, char* argv[])  
120. {  
121.     Test test;  
122.     return EXIT_SUCCESS;  
123. }  

结果：  类H的构造函数   （static 成员类，而且被初始化了）
类C的构造函数        （虚拟继承基类）
类D的构造函数
抽象类A的构造函数    （ 非虚拟继承基类）
抽象类B的构造函数
类E的构造函数
类F的构造函数
类G的构造函数        （普通成员对象构造）
类Test的构造函数      （派生类自己构造函数）