C++中类的构造函数调用顺序

当建立一个对象时，首先调用基类的构造函数，然后调用下一个派生类的
构造函数，依次类推，直至到达派生类次数最多的派生次数最多的类的构造函数为止。
简而言之，对象是由“底层向上”开始构造的。因为，构造函数一开始构造时，总是
要调用它的基类的构造函数，然后才开始执行其构造函数体，调用直接基类构造函数时，
如果无专门说明，就调用直接基类的默认构造函数。在对象析构时，其顺序正好相反。

下面的这个程序说明这个问题

总结下来，我们必须明确的是当一个类继承与基类，并且自身还包含有其他类的成员对象的时候，构造函数的调用顺序为：调用基类的构造函数->调用成员对象的构造函数->调用自身的构造函数。构造函数的调用次序完全不受构造函数初始化列表的表达式中的次序影响，与基类的声明次数和成员对象在函数中的声明次序有关。

1. C++子类和父类的构造函数调用顺序

[cpp] view plaincopy

1. #include <iostream>
2. using namespace std;
3. //子类
4. class base
5. {
6. public:
7. base()
8. {
9. cout<<"i am base constuction!"<<endl;
10. }
11. };
12. //父类
13. class drived : public base
14. {
15. public:
16. drived()
17. {
18. cout<<"i am drived constuction!"<<endl;
19. }
20. };
21. int main()
22. {
23. drived d;
24. //输出结果
25. /*
26. i am base constuction!
27. i am drived constuction!
28. Press any key to continue
29. */
30. return 0;
31. }

由输出结果我们可以看到，先调用的是base类的构造函数，再调用了drived类的构造函数，也就是说，在声明子类实例的时候，是会先调用父类的构造函数的。这个很好理解，子类是包含了父类的信息的，所以要构造子类，必须先构造父类的信息，然后加入一些子类的新信息。

成员类的构造函数调用顺序

[cpp] view plaincopy

1. #include <iostream>
2. using namespace std;
3. class son
4. {
5. public:
6. son()
7. {
8. cout<<"i am son constuction!"<<endl;
9. }
10. };
11. class family
12. {
13. public:
14. family()
15. {
16. cout<<"i am family constuction!"<<endl;
17. }
18. son jack;
19. };
20. int main()
21. {
22. family happyfamily;
23. //输出结果
24. /*
25. i am son constuction!
26. i am family constuction!
27. Press any key to continue
28. */
29. return 0;
30. }

从上面的结果我们科看到，先调用的是构造函数。这是为什么？因为类中含有成员类时，先要给成员类申请空间，先调用成员类的构造函数，然后再调用自身的构造函数。

[cpp] view plaincopy

1. #include <iostream>
2. using namespace std;
3. //父亲姓名
4. class name
5. {
6. public:
7. name()
8. {
9. cout<<"i am name constuction!"<<endl;
10. }
11. };
12. //子类
13. class base
14. {
15. public:
16. base()
17. {
18. cout<<"i am base constuction!"<<endl;
19. }
20. };
21. //父类
22. class drived : public base
23. {
24. public:
25. drived()
26. {
27. cout<<"i am drived constuction!"<<endl;
28. }
29. name drivedname;
30. };
31. int main()
32. {
33. drived d;
34. //输出结果
35. /*
36. i am base constuction!
37. i am name constuction!
38. i am drived constuction!
39. Press any key to continue
40. */
41. return 0;
42. }

上面的例子是声明了一个name类，一个base类，一个drived类，其中drived类是从base类派生，且drived类中声明了name类的一个实例。

那么根据我们上面的分析，我们声明了drived类之后，先会调用父类构造函数，也就是输出i am base construction，然后调用自身的成员类构造函数，也就是i am name construction，最后调用自身的构造函数，也就是i am drived construction。

同理，如果我们在父类base类中声明了name成员类的话，顺序会是name->base->drived。我下面给出测试例子：

[cpp] view plaincopy

1. #include <iostream>
2. using namespace std;
3. //父亲姓名
4. class name
5. {
6. public:
7. name()
8. {
9. cout<<"i am name constuction!"<<endl;
10. }
11. };
12. //子类
13. class base
14. {
15. public:
16. base()
17. {
18. cout<<"i am base constuction!"<<endl;
19. }
20. name drivedname;
21. };
22. //父类
23. class drived : public base
24. {
25. public:
26. drived()
27. {
28. cout<<"i am drived constuction!"<<endl;
29. }
30. };
31. int main()
32. {
33. drived d;
34. //输出结果
35. /*
36. i am name constuction!
37. i am base constuction!
38. i am drived constuction!
39. Press any key to continue
40. */
41. return 0;
42. }

版权声明：本文为【借你一秒】原创文章，转载请标明出处。