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的构造函数，然后按照层级，一层一层下来。
