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

1.参考文献

参考1： C++继承中构造函数、析构函数调用顺序及虚函数的动态绑定

参考2： 构造函数、拷贝构造函数和析构函数的的调用时刻及调用顺序

参考3： C++构造函数与析构函数的调用顺序

2.构造函数、析构函数与拷贝构造函数介绍

2.1构造函数

• 构造函数不能有返回值
• 缺省构造函数时，系统将自动调用该缺省构造函数初始化对象，缺省构造函数会将所有数据成员都初始化为零或空 
• 创建一个对象时，系统自动调用构造函数

2.2析构函数

• 析构函数没有参数，也没有返回值。不能重载，也就是说，一个类中只可能定义一个析构函数
• 如果一个类中没有定义析构函数，系统也会自动生成一个默认的析构函数，为空函数，什么都不做
• 调用条件：1.在函数体内定义的对象，当函数执行结束时，该对象所在类的析构函数会被自动调用；2.用new运算符动态构建的对象，在使用delete运算符释放它时。

2.3拷贝构造函数

拷贝构造函数实际上也是构造函数，具有一般构造函数的所有特性，其名字也与所属类名相同。拷贝构造函数中只有一个参数，这个参数是对某个同类对象的引用。它在三种情况下被调用：

• 用类的一个已知的对象去初始化该类的另一个对象时；
• 函数的形参是类的对象，调用函数进行形参和实参的结合时；
• 函数的返回值是类的对象，函数执行完返回调用者。

3.构造函数与析构函数的调用顺序

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

4.实例1

4.1代码

[cpp]  view plain copy

1. #include<iostream>  
2. using namespace std;  
3. class point  
4. {  
5. private:  
6.     int x,y;//数据成员  
7. public:  
8.     point(int xx=0,int yy=0)//构造函数  
9.     {  
10.         x=xx;  
11.         y=yy;  
12.         cout<<"构造函数被调用"<<endl;  
13.     }  
14.     point(point &p);//拷贝构造函数，参数是对象的引用  
15.     ~point(){cout<<"析构函数被调用"<<endl;}  
16.     int get_x(){return x;}//方法  
17.     int get_y(){return y;}  
18. };  
19.   
20. point::point(point &p)  
21. {  
22.     x=p.x;//将对象p的变相赋值给当前成员变量。  
23.     y=p.y;  
24.     cout<<"拷贝构造函数被调用"<<endl;  
25. }  
26.   
27. void f(point p)  
28. {  
29.     cout<<p.get_x()<<"  "<<p.get_y()<<endl;  
30. }  
31.   
32. point g()//返回类型是point  
33. {  
34.     point a(7,33);  
35.     return a;  
36. }  
37.   
38. void main()  
39. {  
40.     point a(15,22);  
41.     point b(a);//构造一个对象，使用拷贝构造函数。  
42.     cout<<b.get_x()<<"  "<<b.get_y()<<endl;  
43.     f(b);  
44.     b=g();  
45.     cout<<b.get_x()<<"  "<<b.get_y()<<endl;  
46. }  

4.2运行结果

4.3结果解析

构造函数被调用  //point a(15,22);
拷贝构造函数被调用 //point b(a);拷贝构造函数的第一种调用情况： 用类的一个已知的对象去初始化该类的另一个对象时
15 22 //cout<<b.get_x()<<" "<<b.get_y()<<endl;

拷贝构造函数被调用 //f(b);拷贝构造函数的第二种调用情况： 函数的形参是类的对象，调用函数进行形参和实参的结合时
15 22  //void f(point p)函数输出对象b的成员
析构函数被调用 //f(b);析构函数的第一种调用情况： 在函数体内定义的对象，当函数执行结束时，该对象所在类的析构函数会被自动调用
构造函数被调用 //b=g();的函数体内point a(7,33);创建对象a
拷贝构造函数被调用 //b=g();拷贝构造函数的第三种调用情况，拷贝a的值赋给b： 函数的返回值是类的对象，函数执行完返回调用者
析构函数被调用 //拷贝构造函数对应的析构函数
析构函数被调用 //b=g();的函数体内对象a析构
7 33
析构函数被调用 //主函数体b对象的析构
析构函数被调用 //主函数体a对象的析构

5.实例2

5.1代码

[cpp]  view plain copy

1. #include <iostream>  
2. using namespace std;  
3. //基类  
4. class CPerson  
5. {  
6.     char *name;        //姓名  
7.     int age;            //年龄  
8.     char *add;        //地址  
9. public:  
10.     CPerson(){cout<<"constructor - CPerson! "<<endl;}  
11.     ~CPerson(){cout<<"deconstructor - CPerson! "<<endl;}  
12. };  
13.   
14. //派生类(学生类)  
15. class CStudent : public CPerson  
16. {  
17.     char *depart;    //学生所在的系  
18.     int grade;        //年级  
19. public:  
20.     CStudent(){cout<<"constructor - CStudent! "<<endl;}  
21.     ~CStudent(){cout<<"deconstructor - CStudent! "<<endl;}  
22. };  
23.   
24. //派生类(教师类)  
25. //class CTeacher : public CPerson//继承CPerson类，两层结构  
26. class CTeacher : public CStudent//继承CStudent类，三层结构  
27. {  
28.     char *major;    //教师专业  
29.     float salary;    //教师的工资  
30. public:  
31.     CTeacher(){cout<<"constructor - CTeacher! "<<endl;}  
32.     ~CTeacher(){cout<<"deconstructor - CTeacher! "<<endl;}  
33. };  
34.   
35. //实验主程序  
36. void main()  
37. {  
38.     //CPerson person;  
39.     //CStudent student;  
40.     CTeacher teacher;  
41. }  

5.2运行结果

5.3说明

在实例2中，CPerson是CStudent的父类，而CStudent又是CTeacher的父类，那么在创建CTeacher对象的时候，首先调用基类也就是CPerson的构造函数，然后按照层级，一层一层下来。