码迷，mamicode.com
首页 > 编程语言 > 详细

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

时间：2015-09-23 19:30:56      阅读：175      评论：0      收藏：0      [点我收藏+]

标签：c++   构造函数   继承   class   

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

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


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


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

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

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

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

  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.   
  32. int main()  
  33. {  
  34.     drived d;  
  35.     //输出结果  
  36.     /* 
  37.     i am base constuction! 
  38.     i am name constuction! 
  39.     i am drived constuction! 
  40.     Press any key to continue 
  41.  
  42.     */  
  43.     return 0;  
  44. }  

上面的例子是声明了一个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。我下面给出测试例子：
  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. };  
  32.   
  33. int main()  
  34. {  
  35.     drived d;  
  36.     //输出结果  
  37.     /* 
  38.     i am name constuction! 
  39.     i am base constuction! 
  40.     i am drived constuction! 
  41.     Press any key to continue 
  42.     */  
  43.     return 0;  
  44. }  


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

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

标签：c++   构造函数   继承   class   

原文地址：http://blog.csdn.net/u013467442/article/details/48682663
踩
(0)
赞
(0)
   
举报
评论 一句话评论（0）
登录后才能评论！
分享档案
更多>
2021年07月29日 (22)
2021年07月28日 (40)
2021年07月27日 (32)
2021年07月26日 (79)
2021年07月23日 (29)
2021年07月22日 (30)
2021年07月21日 (42)
2021年07月20日 (16)
2021年07月19日 (90)
2021年07月16日 (35)
周排行
mamicode.com排行更多图片
更多
友情链接
兰亭集智   国之画   百度统计   站长统计   阿里云   chrome插件   新版天听网
关于我们 - 联系我们 - 留言反馈
© 2014 mamicode.com 版权所有  联系我们:gaon5@hotmail.com
迷上了代码！