构造函数、拷贝构造函数和析构函数的的调用时刻及调用顺序
2014-03-04 11:19
330 查看
对象是由“底层向上”开始构造的，当建立一个对象时，首先调用基类的构造函数，然后调用下一个派生类的构造函数，依次类推，直至到达派生类次数最多的派生次数最多的类的构造函数为止。因为，构造函数一开始构造时，总是要调用它的基类的构造函数，然后才开始执行其构造函数体，调用直接基类构造函数时，如果无专门说明，就调用直接基类的默认构造函数。在对象析构时，其顺序正好相反。 下面简单介绍下这三个函数。
构造函数
1.构造函数不能有返回值
2.缺省构造函数时，系统将自动调用该缺省构造函数初始化对象，缺省构造函数会将所有数据成员都
初始化为零或空
3.创建一个对象时，系统自动调用构造函数
析构函数
析构函数没有参数，也没有返回值。不能重载，也就是说，一个类中只可能定义一个析构函数
如果一个类中没有定义析构函数，系统也会自动生成一个默认的析构函数，为空函数，什么都不做
调用条件：1.在函数体内定义的对象，当函数执行结束时，该对象所在类的析构函数会被自动调用；
2.用new运算符动态构建的对象，在使用delete运算符释放它时。
拷贝构造函数
拷贝构造函数实际上也是构造函数，具有一般构造函数的所有特性，其名字也与所属类名相同。拷贝构造函数中只有一个参数，这个参数是对某个同类对象的引用。
！！！在三种情况下被调用：
1.用类的一个已知的对象去初始化该类的另一个对象时；
2.函数的形参是类的对象，调用函数进行形参和实参的结合时；
3.函数的返回值是类的对象，函数执行完返回调用者。
实例：
#include <iostream.h>
class point
{
private:
int x,y;
public:
point(int xx=0,int yy=0)
{
x=xx;
y=yy;
cout<<"构造函数被调用"<<endl;
}
point(point &p);
~point(){cout<<"析构函数被调用"<<endl;}
int get_x(){return x;}
int get_y(){return y;}
};
point::point(point &p)
{
x=p.x;
y=p.y;
cout<<"拷贝构造函数被调用"<<endl;
}
void f(point p)
{
cout<<p.get_x()<<p.get_y<<endl;
}
point g()
{
point a(7,33);
return a;
}
void main()
{
point a(15,22);
point b(a);
cout<<b.get_x()<<""<<b.get_y()<<endl;
f(b);
b=g();
cout<<b.get_x<<""<<b.get_y()<<endl;
}
程序运行结果：
构造函数被调用 //point a(15,22);
拷贝构造函数被调用//point b(a);拷贝构造函数的第一种调用情况
15 22
拷贝构造函数被调用//f(b);拷贝构造函数的第二种调用情况
15 22
析构函数被调用//f(b);析构函数的第一种调用情况
构造函数被调用//b=g();的函数体内point a(7,33);创建对象a
拷贝构造函数被调用//g()返回a时会创建一个临时对象,以a为参数,调用拷贝构造函数 //此处与原作者意见有不同,有修改
析构函数被调用//临时对象对应的析构函数 //此处与原作者意见有不同,有修改
析构函数被调用//b=g();的函数体内对象a析构
7 33
析构函数被调用//主函数体b对象的析构
析构函数被调用//主函数体a对象的析构
由此看出：析构函数的顺序与构造函数的顺序刚好相反
附录A：
定义一个基类、两个派生类，分别定义其对象，观察其构造、析构函数的调用顺序
代码如下：
/**//************************************************************************
* 基类、派生类的构造、析构函数的调用顺序
************************************************************************/
#include <iostream.h>
//基类
class CPerson
...{
char *name; //姓名
int age; //年龄
char *add; //地址
public:
CPerson()...{cout<<"constructor - CPerson! ";}
~CPerson()...{cout<<"deconstructor - CPerson! ";}
};
//派生类(学生类)
class CStudent : public CPerson
...{
char *depart; //学生所在的系
int grade; //年级
public:
CStudent()...{cout<<"constructor - CStudent! ";}
~CStudent()...{cout<<"deconstructor - CStudent! ";}
};
//派生类(教师类)
class CTeacher : public CPerson
...{
char *major; //教师专业
float salary; //教师的工资
public:
CTeacher()...{cout<<"constructor - CTeacher! ";}
~CTeacher()...{cout<<"deconstructor - CTeacher! ";}
};
//实验主程序
void main()
...{
CPerson person;
CStudent student;
CTeacher teacher;
}
运行结果：
附录C# 相关
c# 构造函数--构造函数名与类同名
1、缺省构造函数时：
class TestClass
{
public TestClass(): base() {} // 由CLR提供
}
2、实例构造函数
实例构造函数是实现对类中实例进行初始化的方法成员
3、静态构造函数
静态构造函数是实现对一个类进行初始化的方法成员。它一般用于对静态数据的初始化。静态构造函
数不能有参数，不能有修饰符而且不能被调用，当类被加载时，类的静态构造函数自动被调用。
声明了一个有静态构造函数的类Employee。注意静态构造函数只能对静态数据成员进行初始化，而不
能对非静态数据成员进行初始化。但是，非静态构造函数既可以对静态数据成员赋值，也可以对非静态数
据成员进行初始化。
4、如果类仅包含静态成员，你可以创建一个private的构造函数：private TestClass() {…}，但是
private意味着从类的外面不可能访问该构造函数。所以，它不能被调用，且没有对象可以被该类定义实
例化
———————————————————————————————————————————
在类的层次结构中（即继承结构中）基类和派生类的构造函数的使用方式。派生类对象的初始化由基
类和派生类共同完成：****基类的成员由基类的构造函数初始化，派生类的成员由派生类的构造函数初始
化。
当创建派生类的对象时，系统将会调用基类的构造函数和派生类的构造函数，****构造函数的执行次
序是：先执行基类的构造函数，再执行派生类的构造函数。****如果派生类又有对象成员，则，先执行基
类的构造函数，再执行成员对象类的构造函数，最后执行派生类的构造函数。
****至于执行基类的什么构造函数，缺省情况下是执行基类的无参构造函数，如果要执行基类的有参
构造函数，则必须在派生类构造函数的成员初始化表中指出。
class A
{ private int x;
public A( ) { x = 0; }
public A( int i ) { x = i; }
};
class B : A
{ private int y;
public B( ) { y = 0; }
public B( int i ) { y = i; }
public B( int i, int j ):A(i) { y = j; }
};
B b1 = new B(); //执行基类A的构造函数A()，再执行派生类的构造函数B()
B b2 = new B(1); //执行基类A的构造函数A()，再执行派生类的构造函数B(int)
B b3 = new B(0,1); //执行执行基类A的构造函数A(int) ，再执行派生类的
构造函数B(int,int)
在这里构造函数的执行次序是一定要分析清楚的。另外，如果基类A中没有提供无参构造函数public
A( ) { x = 0; }，则在派生类的所有构造函数成员初始化表中必须指出基类A的有参构造函数A(i)，如下
所示：
class A
{ private int x;
public A( int i ) { x = i; }
};
class B : A
{ private int y;
public B():A(i) { y = 0; }
public B(int i):A(i) { y = i; }
public B(int i, int j):A(i) { y = j; }
};
————————————————————————————————————————————
析构函数和垃圾回收器在C#中的运用
析构函数是实现销毁一个类的实例的方法成员。析构函数不能有参数，不能任何修饰符而且不能被调
用。由于析构函数的目的与构造函数的相反，就加前缀‘~’以示区别。
虽然C#（更确切的说是CLR）提供了一种新的内存管理机制---自动内存管理机制（Automatic memory
management），资源的释放是可以通过“垃圾回收器” 自动完成的，一般不需要用户干预，但在有些特
殊情况下还是需要用到析构函数的，如在C#中非托管资源的释放。
资源的释放一般是通过"垃圾回收器"自动完成的,但具体来说,仍有些需要注意的地方：
1. 值类型和引用类型的引用其实是不需要什么"垃圾回收器"来释放内存的,因为当它们出了作用域后
会自动释放所占内存，因为它们都保存在栈(Stack)中;
2. 只有引用类型的引用所指向的对象实例才保存在堆(Heap)中,而堆因为是一个自由存储空间,所以
它并没有像"栈"那样有生存期("栈"的元素弹出后就代表生存期结束,也就代表释放了内存),并且要注意的
是,"垃圾回收器"只对这块区域起作用;
然而,有些情况下，当需要释放非托管资源时,就必须通过写代码的方式来解决。通常是使用析构函数
释放非托管资源，将用户自己编写的释放非托管资源的代码段放在析构函数中即可。需要注意的是,如果
一个类中没有使用到非托管资源,那么一定不要定义析构函数,这是因为对象执行了析构函数,那么"垃圾回
收器"在释放托管资源之前要先调用析构函数，然后第二次才真正释放托管资源，这样一来，两次删除动
作的花销比一次大多的。下面使用一段代码来示析构函数是如何使用的：
public class ResourceHolder
{
…
~ResourceHolder()
{
// 这里是清理非托管资源的用户代码段
}
}
小结
构造函数与析构函数虽然是一个类中形式上较简单的函数，但它们的使用决非看上去那么简单，因此
灵活而正确的使用构造函数与析构函数能够帮你更好的理解CLR的内存管理机制，以及更好的管理系统中
的资源。
原文链接,感谢原作者
别人的评论:
"
请教您一个问题
关于您说的拷贝构造函数调用的第三种情况
在您的示例中，如果在调用b=g()的时候，我新定义一个point类的变量c来接受g()的返回值，即把“b= g()”替换为“point c = g()”，运行时，出现的结果让我不是很理解，好像此时有拷贝构造函数的调用，但是没有临时变量的析构。另外我觉得既然这里c是新定义的变量，按道理要调用拷贝构造函数才对，属于您说的调用拷贝构造函数的第一种情况，可是结果跟我预想的大相径庭，故向您请教。
您的例子我能看懂，也能理解，可是换为我自己替换之后的情况，我就不理解了！！！
"
我做的回答:
"
首先我觉得笔者的两点解释,可能会误导
"拷贝构造函数被调用//b=g();拷贝构造函数的第三种调用情况，拷贝a的值赋给b。
析构函数被调用//拷贝构造函数对应的析构函数"
这里应该是,返回a时,会创建一个临时对象(以返回的a为参数)调用拷贝构造函数,然后在把这个对象的值复制给对象b,根本不是b以a做参数调用拷贝构造函数,
之后的析构函数的调用,是对临时对象的析构函数的调用
你可以做个测试
point d;
cout << "ceshi" << endl;
d = a;
cout << "ceshi" << endl;
这里d = a是不会调用拷贝构造函数和构造函数的
最简单的,point d = a;这里本应该还会调用拷贝构造函数,只是编译器做了优化,可能在你的问题中,通过g()返回的时候,直接给了c对象.这样,在最后的时候才会释放c,所以,你仔细看,在最后面的时候,会多出一个析构函数(point c = g() 相对于b = g())
"
构造函数
1.构造函数不能有返回值
2.缺省构造函数时，系统将自动调用该缺省构造函数初始化对象，缺省构造函数会将所有数据成员都
初始化为零或空
3.创建一个对象时，系统自动调用构造函数
析构函数
析构函数没有参数，也没有返回值。不能重载，也就是说，一个类中只可能定义一个析构函数
如果一个类中没有定义析构函数，系统也会自动生成一个默认的析构函数，为空函数，什么都不做
调用条件：1.在函数体内定义的对象，当函数执行结束时，该对象所在类的析构函数会被自动调用；
2.用new运算符动态构建的对象，在使用delete运算符释放它时。
拷贝构造函数
拷贝构造函数实际上也是构造函数，具有一般构造函数的所有特性，其名字也与所属类名相同。拷贝构造函数中只有一个参数，这个参数是对某个同类对象的引用。
！！！在三种情况下被调用：
1.用类的一个已知的对象去初始化该类的另一个对象时；
2.函数的形参是类的对象，调用函数进行形参和实参的结合时；
3.函数的返回值是类的对象，函数执行完返回调用者。
实例：
#include <iostream.h>
class point
{
private:
int x,y;
public:
point(int xx=0,int yy=0)
{
x=xx;
y=yy;
cout<<"构造函数被调用"<<endl;
}
point(point &p);
~point(){cout<<"析构函数被调用"<<endl;}
int get_x(){return x;}
int get_y(){return y;}
};
point::point(point &p)
{
x=p.x;
y=p.y;
cout<<"拷贝构造函数被调用"<<endl;
}
void f(point p)
{
cout<<p.get_x()<<p.get_y<<endl;
}
point g()
{
point a(7,33);
return a;
}
void main()
{
point a(15,22);
point b(a);
cout<<b.get_x()<<""<<b.get_y()<<endl;
f(b);
b=g();
cout<<b.get_x<<""<<b.get_y()<<endl;
}
程序运行结果：
构造函数被调用 //point a(15,22);
拷贝构造函数被调用//point b(a);拷贝构造函数的第一种调用情况
15 22
拷贝构造函数被调用//f(b);拷贝构造函数的第二种调用情况
15 22
析构函数被调用//f(b);析构函数的第一种调用情况
构造函数被调用//b=g();的函数体内point a(7,33);创建对象a
拷贝构造函数被调用//g()返回a时会创建一个临时对象,以a为参数,调用拷贝构造函数 //此处与原作者意见有不同,有修改
析构函数被调用//临时对象对应的析构函数 //此处与原作者意见有不同,有修改
析构函数被调用//b=g();的函数体内对象a析构
7 33
析构函数被调用//主函数体b对象的析构
析构函数被调用//主函数体a对象的析构
由此看出：析构函数的顺序与构造函数的顺序刚好相反
附录A：
定义一个基类、两个派生类，分别定义其对象，观察其构造、析构函数的调用顺序
代码如下：
/**//************************************************************************
* 基类、派生类的构造、析构函数的调用顺序
************************************************************************/
#include <iostream.h>
//基类
class CPerson
...{
char *name; //姓名
int age; //年龄
char *add; //地址
public:
CPerson()...{cout<<"constructor - CPerson! ";}
~CPerson()...{cout<<"deconstructor - CPerson! ";}
};
//派生类(学生类)
class CStudent : public CPerson
...{
char *depart; //学生所在的系
int grade; //年级
public:
CStudent()...{cout<<"constructor - CStudent! ";}
~CStudent()...{cout<<"deconstructor - CStudent! ";}
};
//派生类(教师类)
class CTeacher : public CPerson
...{
char *major; //教师专业
float salary; //教师的工资
public:
CTeacher()...{cout<<"constructor - CTeacher! ";}
~CTeacher()...{cout<<"deconstructor - CTeacher! ";}
};
//实验主程序
void main()
...{
CPerson person;
CStudent student;
CTeacher teacher;
}
运行结果：
附录C# 相关
c# 构造函数--构造函数名与类同名
1、缺省构造函数时：
class TestClass
{
public TestClass(): base() {} // 由CLR提供
}
2、实例构造函数
实例构造函数是实现对类中实例进行初始化的方法成员
3、静态构造函数
静态构造函数是实现对一个类进行初始化的方法成员。它一般用于对静态数据的初始化。静态构造函
数不能有参数，不能有修饰符而且不能被调用，当类被加载时，类的静态构造函数自动被调用。
声明了一个有静态构造函数的类Employee。注意静态构造函数只能对静态数据成员进行初始化，而不
能对非静态数据成员进行初始化。但是，非静态构造函数既可以对静态数据成员赋值，也可以对非静态数
据成员进行初始化。
4、如果类仅包含静态成员，你可以创建一个private的构造函数：private TestClass() {…}，但是
private意味着从类的外面不可能访问该构造函数。所以，它不能被调用，且没有对象可以被该类定义实
例化
———————————————————————————————————————————
在类的层次结构中（即继承结构中）基类和派生类的构造函数的使用方式。派生类对象的初始化由基
类和派生类共同完成：****基类的成员由基类的构造函数初始化，派生类的成员由派生类的构造函数初始
化。
当创建派生类的对象时，系统将会调用基类的构造函数和派生类的构造函数，****构造函数的执行次
序是：先执行基类的构造函数，再执行派生类的构造函数。****如果派生类又有对象成员，则，先执行基
类的构造函数，再执行成员对象类的构造函数，最后执行派生类的构造函数。
****至于执行基类的什么构造函数，缺省情况下是执行基类的无参构造函数，如果要执行基类的有参
构造函数，则必须在派生类构造函数的成员初始化表中指出。
class A
{ private int x;
public A( ) { x = 0; }
public A( int i ) { x = i; }
};
class B : A
{ private int y;
public B( ) { y = 0; }
public B( int i ) { y = i; }
public B( int i, int j ):A(i) { y = j; }
};
B b1 = new B(); //执行基类A的构造函数A()，再执行派生类的构造函数B()
B b2 = new B(1); //执行基类A的构造函数A()，再执行派生类的构造函数B(int)
B b3 = new B(0,1); //执行执行基类A的构造函数A(int) ，再执行派生类的
构造函数B(int,int)
在这里构造函数的执行次序是一定要分析清楚的。另外，如果基类A中没有提供无参构造函数public
A( ) { x = 0; }，则在派生类的所有构造函数成员初始化表中必须指出基类A的有参构造函数A(i)，如下
所示：
class A
{ private int x;
public A( int i ) { x = i; }
};
class B : A
{ private int y;
public B():A(i) { y = 0; }
public B(int i):A(i) { y = i; }
public B(int i, int j):A(i) { y = j; }
};
————————————————————————————————————————————
析构函数和垃圾回收器在C#中的运用
析构函数是实现销毁一个类的实例的方法成员。析构函数不能有参数，不能任何修饰符而且不能被调
用。由于析构函数的目的与构造函数的相反，就加前缀‘~’以示区别。
虽然C#（更确切的说是CLR）提供了一种新的内存管理机制---自动内存管理机制（Automatic memory
management），资源的释放是可以通过“垃圾回收器” 自动完成的，一般不需要用户干预，但在有些特
殊情况下还是需要用到析构函数的，如在C#中非托管资源的释放。
资源的释放一般是通过"垃圾回收器"自动完成的,但具体来说,仍有些需要注意的地方：
1. 值类型和引用类型的引用其实是不需要什么"垃圾回收器"来释放内存的,因为当它们出了作用域后
会自动释放所占内存，因为它们都保存在栈(Stack)中;
2. 只有引用类型的引用所指向的对象实例才保存在堆(Heap)中,而堆因为是一个自由存储空间,所以
它并没有像"栈"那样有生存期("栈"的元素弹出后就代表生存期结束,也就代表释放了内存),并且要注意的
是,"垃圾回收器"只对这块区域起作用;
然而,有些情况下，当需要释放非托管资源时,就必须通过写代码的方式来解决。通常是使用析构函数
释放非托管资源，将用户自己编写的释放非托管资源的代码段放在析构函数中即可。需要注意的是,如果
一个类中没有使用到非托管资源,那么一定不要定义析构函数,这是因为对象执行了析构函数,那么"垃圾回
收器"在释放托管资源之前要先调用析构函数，然后第二次才真正释放托管资源，这样一来，两次删除动
作的花销比一次大多的。下面使用一段代码来示析构函数是如何使用的：
public class ResourceHolder
{
…
~ResourceHolder()
{
// 这里是清理非托管资源的用户代码段
}
}
小结
构造函数与析构函数虽然是一个类中形式上较简单的函数，但它们的使用决非看上去那么简单，因此
灵活而正确的使用构造函数与析构函数能够帮你更好的理解CLR的内存管理机制，以及更好的管理系统中
的资源。
原文链接,感谢原作者
别人的评论:
"
请教您一个问题
关于您说的拷贝构造函数调用的第三种情况
在您的示例中，如果在调用b=g()的时候，我新定义一个point类的变量c来接受g()的返回值，即把“b= g()”替换为“point c = g()”，运行时，出现的结果让我不是很理解，好像此时有拷贝构造函数的调用，但是没有临时变量的析构。另外我觉得既然这里c是新定义的变量，按道理要调用拷贝构造函数才对，属于您说的调用拷贝构造函数的第一种情况，可是结果跟我预想的大相径庭，故向您请教。
您的例子我能看懂，也能理解，可是换为我自己替换之后的情况，我就不理解了！！！
"
我做的回答:
"
首先我觉得笔者的两点解释,可能会误导
"拷贝构造函数被调用//b=g();拷贝构造函数的第三种调用情况，拷贝a的值赋给b。
析构函数被调用//拷贝构造函数对应的析构函数"
这里应该是,返回a时,会创建一个临时对象(以返回的a为参数)调用拷贝构造函数,然后在把这个对象的值复制给对象b,根本不是b以a做参数调用拷贝构造函数,
之后的析构函数的调用,是对临时对象的析构函数的调用
你可以做个测试
point d;
cout << "ceshi" << endl;
d = a;
cout << "ceshi" << endl;
这里d = a是不会调用拷贝构造函数和构造函数的
最简单的,point d = a;这里本应该还会调用拷贝构造函数,只是编译器做了优化,可能在你的问题中,通过g()返回的时候,直接给了c对象.这样,在最后的时候才会释放c,所以,你仔细看,在最后面的时候,会多出一个析构函数(point c = g() 相对于b = g())
"
内容来自用户分享和网络整理，不保证内容的准确性，如有侵权内容，可联系管理员处理 
相关文章推荐
- DuiLib编译问题及解决
- Android面试汇总
- NGUI ROOT
- pyrailgun 0.24 : Python Package Index
- ext button 属性
- cordova 入门
- eclipse更改xml文字大小的方法
- 黑马程序员_string字符串
- mysql常用的字符串函数
- 有限状态机（FSM）的分类
- Ubuntu中gvim中文输入法ibus无法使用的问题
- session 和 cookie 的区别
- Tree_Graph 打印所有和为定值的路径 @CareerCup
- 【2】播放器一般原理
- adb shell 启动，停止 android 应用程序
- Fedora 19解决google浏览器不能启动的问题
- 怎样使一个Android应用不被杀死？
- regular expression(正则表达式)
- 如何用PHP来编写自己的模板引擎
- 每日英语:Why Mom's Time Is Different From Dad's Time