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

http://blog.csdn.net/xw13106209/article/details/6899370

1.参考文献

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

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

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

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

2.1构造函数

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

2.2析构函数

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

2.3拷贝构造函数

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

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

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

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

4.实例1

4.1代码

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

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代码

 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 int main()
37 {
38     CPerson person;
39     CStudent student;
40     CTeacher teacher;
41 }

5.3说明

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

时间: 09-10

C++C++中构造函数与析构函数的调用顺序的相关文章

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

一般而言,析构函数调用的顺序和构造函数调用顺序相反,但是,对象的存储类别可以改变调用析构函数的顺序.举例说明: CreateAndDestroy类的定义 CreateAndDestroy类的成员函数的定义 测试函数 构造函数和析构函数的调用顺序: 分析 全局作用域内定义的对象的构造函数,在文件内任何其他函数(包括main函数)开始执行之前调用,当main函数执行结束时,相应的析构函数被调用,如上面的Object 1. exit函数迫使程序立即结束,不执行自动对象的析构函数.当程序中检测到输入中有

c++学习笔记5,多重继承中派生类的构造函数与析构函数的调用顺序(二)

现在来测试一下在多重继承,虚继承,MI继承中虚继承中构造函数的调用情况. 先来测试一些普通的多重继承.其实这个是显而易见的. 测试代码: //测试多重继承中派生类的构造函数的调用顺序何时调用 //Fedora20 gcc version=4.8.2 #include <iostream> using namespace std; class base { public: base() { cout<<"base created!"<<endl; }

【C/C++】构造函数与析构函数的调用顺序

常见问题 Q1. 以下代码的输出结果是什么? 1 #include <iostream> 2 using namespace std; 3 4 class A 5 { 6 public: 7 A() { cout << "A" << endl; } 8 ~A() { cout << "~A" << endl; } 9 }; 10 class B : public A 11 { 12 public: 13 B

C++:派生类的构造函数和析构函数的调用顺序

一.派生类 在C++编程中,我们在编写一个基类的派生类时,大致可以分为四步: ? 吸收基类的成员:不论是数据成员还是函数成员,派生类吸收除基类的构造函数和析构函数之外的全部成员. ? 改造基类函数:在派生类中声明一个或多个与其(某个)基类中的成员函数同名的成员函数,并将它(们)根据新的需求进行重写 ? 发展新的成员:在派生类中添加新的成员变量和成员函数,其中新添加的成员要求必须和基类中的成员不同名,并且应当保证新添加的成员会使派生类在功能上相比其基类有所发展 ? 重写派生类的构造函数和析构函数

c++学习笔记4,派生类的构造函数与析构函数的调用顺序(一)

測试源代码: //測试派生类的构造函数的调用顺序何时调用 //Fedora20 gcc version=4.8.2 #include <iostream> using namespace std; class base { public: base() { cout<<"base created!"<<endl; } ~base() { cout<<"base destroyed!"<<endl; } };

C++中多态中构造函数与析构函数的调用

做个实验,看一下成员变量的构造析构,父类子类的构造析构,以及虚函数对调用的影响. 1 #include <iostream> 2 using namespace std; 3 4 class Member 5 { 6 public: 7 Member(int n):m_n1(n) 8 { 9 cout<<"Member::Member("<<m_n1<<")"<<endl; 10 } 11 ~Member(

派生类的构造函数与析构函数的调用顺序

派生类构造函数各部分的执行次序为1.调用基类的构造函数,按他们在派生类定义的先后顺序,顺序调用.2.调用成员对象的构造函数,按他们在类定义中声明的先后顺序,顺序调用3.派生类的构造函数体中的操作 在派生类构造函数中,只要基类不是使用缺省构造函数,都要显式给出基类名和参数表如果基类没有定义构造函数,则派生类也可以不定义,全部采用系统给定的缺省构造函数.如果基类定义了带有形参表的构造函数时,派生类就应当定义构造函数. //Test1.h #include<iostream> using names

类的构造函数与析构函数的调用顺序

先来段代码: 1 #include <iostream> 2 using namespace std; 3 4 class Clock{ 5 private: 6 int H,M,S; 7 public: 8 Clock(int h=0,int m=0,int s=0){ 9 H=h,M=m,S=s; 10 cout<<"constructor:"<<H<<":"<<M<<":&quo

C#中构造函数和析构函数的用法

构造函数与析构函数是一个类中看似较为简单的两类函数,但在实际运用过程中总会出现一些意想不到的运行错误.本文将较系统的介绍构造函数与析构函数的原理及在C#中的运用,以及在使用过程中需要注意的若干事项.一.构造函数与析构函数的原理 作为比C更先进的语言,C#提供了更好的机制来增强程序的安全性.C#编译器具有严格的类型安全检查功能,它几乎能找出程序中所有的语法问题,这的确帮了程序员的大忙.但是程序通过了编译检查并不表示错误已经不存在了,在“错误”的大家庭里,“语法错误”的地位只能算是冰山一角.级别高的