几乎所有的面向对象的编程语言都保护构造函数与析构函数,好学者就要举手了,啥情况啊,Java里面不就没有析构函数嘛。好吧,你问倒我了,不过可以认为Java的垃圾自动回收机制实现了对象析构的功能。管他呢,还是看C++的构造函数和析构函数吧。
构造函数
对于C++的构造函数,暂且将其分为以下几类:
1. 默认构造函数
2. 隐士转换构造函数
3. 拷贝构造函数
4. 其它构造函数
1. 默认构造函数表示没有任何参数的构造函数,当自定义任何构造函数以后,将不再自动创建默认构造函数,当然,默认构造函数啥也不干,程序员关心系数顿时大跌。关于默认构造函数还需要关心的一个问题是,当本类继承于另一个类(即父类),父类没有默认构造函数时,本类将自动没有构造函数,并且还必须定义至少能够支持父类初始化的构造函数。
2. 隐士转换构造函数时什么呢?它是这样一类构造函数,这类构造函数仅含有一个参数。由于C++规定,为只含有一个参数的构造函数自动定义一种隐士转换,将构造函数的参数对应数据类型的对象转换为类对象。如下面例子所示:
- class String {
- String(const char *s);
- };
- String s = "hello friends";
其中字符串“hello friends”通过隐士转换构造函数转换为了String类对象s。这里不得不提一个关键字explicit,比较悲剧的是学了好几年C++后才知道这么一个关键字,这也充分体现了一本好书的重要性。下面来看看explicit的用法,再解释。
- class String {
- explicit String(const char *s);
- };
- String s = "hello friends"; //编译不通过
- String s("hello friends"); //编译通过
explicit仅用于构造函数,且仅用于隐士转换构造函数,其目的是禁止隐士构造函数功能。如上代码所示,当为构造函数添加explicit关键字后,String s = "hello friends"; 编译不通过。当然,此时构造函数本身还是能够正常工作的。
3. 拷贝构造函数,就是用来复制对象的一种特殊的构造函数。通过它,可以使用一个已经创建好的对象(由拷贝构造函数的参数指定)去初始化一个正准备创建的同类对象。
- class 类名
- {
- public:
- 类名(类名 &对象名);
- };
如上述代码所述,拷贝构造函数只能有一个参数,并且必须是同类对象的引用。每个类都应该有一个拷贝构造函数,如果用户没有指定,将使用默认的拷贝构造函数。默认拷贝构造函数执行对象的全部内容复制,但有时需要有选择、有变化地复制。这种情况就需要显示定义拷贝构造函数,并实现为感兴趣部分的复制或者为新对象添加某些属性值。
拷贝构造函数最常见的使用方式是在类中含有指针类型属性时,因为默认的拷贝函数是按指拷贝的,即所谓的浅拷贝。这时需要显示定义拷贝构造函数,并显示地将指针从新分配内存并copy以前指向的值到新分配的内存中。
4. 其它构造函数,没什么特别的,就是前面1,2,3未包含的构造函数均属于该类。
构造函数初始化参数列表
以下情况下需要使用初始化成员列表:(待补充)
一、需要初始化的数据成员是对象的情况;
二、需要初始化const修饰的类成员;
第一种情况,如果类A中属性存在一个类B,且类B没有不带参数的构造函数,此时初始化A时也需要初始化B,所以需要初始化参数列表。当然,此种情况一般成员属性也可以通过此种方式初始化。
第二种情况,const成员属性不能复制,一旦初始化后就不能改变。
下面的例子说明构造函数初始化参数列表的使用:
- #include <iostream>
- using namespace std;
- class B
- {
- public:
- B(int b) {
- cout<<b<<endl;
- }
- };
- class A
- {
- public:
- B b;
- A(int a, int ci);
- private:
- const int ci;
- //const int ci = 10; //编译错误,不能初始化
- static const int cv = 10; //添加static关键字后能够编译通过
- int c;
- };
- A::A(int a, int ci):b(a),ci(ci),c(4) {
- cout << ci << "--" << c << endl;
- }
- int main()
- {
- A a(5, 10);
- return 0;
- }
析构函数
析构函数就与构造函数对应,在对象消亡时做一些善后处理。看下面的例子:
- #include <iostream>
- using namespace std;
- class A
- {
- public:
- A() {
- cout << "A..." << endl;
- }
- ~A() {
- cout << "~A" <<endl;
- }
- };
- class B : public A
- {
- public:
- B() {
- cout<<"B..."<<endl;
- }
- ~B() {
- cout<<"~B"<<endl;
- }
- };
- int main() {
- A *a = new B();
- delete a;
- return 0;
- }<span style="font-family: Arial, Verdana, sans-serif; white-space: normal; background-color: rgb(255, 255, 255); "> </span>
编译输出:
- # ./a.out
- A...
- B...
- ~A
由此可见,在对象a消亡时,会自动调用对象A的析构函数。但是C++也太傻了吧,明明我实例化的B对象,可为啥析构时是调用A对象的析构函数呢?看delete a,由此可估计delete关键字只认a的对象,而不会变通。怎么能够这样...
virtual关键字
上面的例子显示,构造了对象B,却没有析构,这会造成啥问题呢?反正我是不清楚了。于是C++提供的virtual关键字可以解决这个问题,看下面的代码:
- #include <iostream>
- using namespace std;
- class A
- {
- public:
- A() {
- cout << "A..." << endl;
- }
- virtual ~A() { //唯一区别:添加了关键字virtual
- cout << "~A" <<endl;
- }
- };
- class B : public A
- {
- public:
- B() {
- cout<<"B..."<<endl;
- }
- ~B() {
- cout<<"~B"<<endl;
- }
- };
- int main() {
- A *a = new B();
- delete a;
- return 0;
- }
输出:
- # ./a.out
- A...
- B...
- ~B
- ~A
可见,添加virtual关键字后,确实能够解决该问题,B对象也调用了析构函数。可是这是为什么呢?
下面开始yy了,也许delete并不是那么傻,她会去虚函数表里面查看当前析构函数是否被定义为虚函数,如果是虚函数,它就会想了,那对象会不会实例化的是子类的对象呢,于是再判断是否实例化为子类对象,如果是就先调用子类的析构函数。
1.参考文献
参考1: C++继承中构造函数、析构函数调用顺序及虚函数的动态绑定
参考2: 构造函数、拷贝构造函数和析构函数的的调用时刻及调用顺序
参考3: C++构造函数与析构函数的调用顺序
2.构造函数、析构函数与拷贝构造函数介绍
2.1构造函数
- 构造函数不能有返回值
- 缺省构造函数时,系统将自动调用该缺省构造函数初始化对象,缺省构造函数会将所有数据成员都初始化为零或空
- 创建一个对象时,系统自动调用构造函数
2.2析构函数
- 析构函数没有参数,也没有返回值。不能重载,也就是说,一个类中只可能定义一个析构函数
- 如果一个类中没有定义析构函数,系统也会自动生成一个默认的析构函数,为空函数,什么都不做
- 调用条件:1.在函数体内定义的对象,当函数执行结束时,该对象所在类的析构函数会被自动调用;2.用new运算符动态构建的对象,在使用delete运算符释放它时。
2.3拷贝构造函数
拷贝构造函数实际上也是构造函数,具有一般构造函数的所有特性,其名字也与所属类名相同。拷贝构造函数中只有一个参数,这个参数是对某个同类对象的引用。它在三种情况下被调用:
- 用类的一个已知的对象去初始化该类的另一个对象时;
- 函数的形参是类的对象,调用函数进行形参和实参的结合时;
- 函数的返回值是类的对象,函数执行完返回调用者。
3.构造函数与析构函数的调用顺序
4.实例1
4.1代码
- #include<iostream>
- using namespace std;
- 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;//将对象p的变相赋值给当前成员变量。
- y=p.y;
- cout<<"拷贝构造函数被调用"<<endl;
- }
- void f(point p)
- {
- cout<<p.get_x()<<" "<<p.get_y()<<endl;
- }
- point g()//返回类型是point
- {
- 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;
- }
4.2运行结果
![](http://hi.csdn.net/attachment/201110/24/0_13194181061Kfk.gif)
拷贝构造函数被调用 //point b(a);拷贝构造函数的第一种调用情况: 用类的一个已知的对象去初始化该类的另一个对象时
15 22 //cout<<b.get_x()<<" "<<b.get_y()<<endl;
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代码
- #include <iostream>
- using namespace std;
- //基类
- class CPerson
- {
- char *name; //姓名
- int age; //年龄
- char *add; //地址
- public:
- CPerson(){cout<<"constructor - CPerson! "<<endl;}
- ~CPerson(){cout<<"deconstructor - CPerson! "<<endl;}
- };
- //派生类(学生类)
- class CStudent : public CPerson
- {
- char *depart; //学生所在的系
- int grade; //年级
- public:
- CStudent(){cout<<"constructor - CStudent! "<<endl;}
- ~CStudent(){cout<<"deconstructor - CStudent! "<<endl;}
- };
- //派生类(教师类)
- //class CTeacher : public CPerson//继承CPerson类,两层结构
- class CTeacher : public CStudent//继承CStudent类,三层结构
- {
- char *major; //教师专业
- float salary; //教师的工资
- public:
- CTeacher(){cout<<"constructor - CTeacher! "<<endl;}
- ~CTeacher(){cout<<"deconstructor - CTeacher! "<<endl;}
- };
- //实验主程序
- void main()
- {
- //CPerson person;
- //CStudent student;
- CTeacher teacher;
- }
5.2运行结果
![](http://hi.csdn.net/attachment/201110/24/0_1319418909EHxH.gif)
5.3说明
1、构造函数和析构函数为什么没有返回值?
构造函数和析构函数是两个非常特殊的函数:它们没有返回值。这与返回值为void的函数显然不同,后者虽然也不返回任何值,但还可以让它做点别的事情,而构造函数和析构函数则不允许。在程序中创建和消除一个对象的行为非常特殊,就像出生和死亡,而且总是由编译器来调用这些函数以确保它们被执行。如果它们有返回值,要么编译器必须知道如何处理返回值,要么就只能由客户程序员自己来显式的调用构造函数与析构函数,这样一来,安全性就被人破坏了。另外,析构函数不带任何参数,因为析构不需任何选项。
如果允许构造函数有返回值,在某此情况下,会引起歧义。如下两个例子
class C { public: C(): x(0) { } C(int i): x(i) { } private: int x; };
如果C的构造函数可以有返回值,比如int:int C():x(0) { return 1; } //1表示构造成功,0表示失败
那么下列代码会发生什么事呢?
C c = C(); //此时c.x == 1!!!
很明显,C()调用了C的无参数构造函数。该构造函数返回int值1。恰好C有一个但参数构造函数C(int i)。于是,混乱来了。按照C++的规定,C c = C();是用默认构造函数创建一个临时对象,并用这个临时对象初始化c。此时,c.x的值应该是0。但是,如果C::C()有返回值,并且返回了1(为了表示成功),则C++会用1去初始化c,即调用但参数构造函数C::C(int i)。得到的c.x便会是1。于是,语义产生了歧义。使得C++原本已经非常复杂的语法,进一步混乱不堪。
构造函数的调用之所以不设返回值,是因为构造函数的特殊性决定的。从基本语义角度来讲,构造函数返回的应当是所构造的对象。否则,我们将无法使用临时对象:
void f(int a) {...} //(1)
void f(const C& a) {...} //(2)
f(C()); //(3),究竟调用谁?
对于(3),我们希望调用的是(2),但如果C::C()有int类型的返回值,那么究竟是调(1)好呢,还是调用(2)好呢。于是,我们的重载体系,乃至整个的语法体系都会崩溃。
这里的核心是表达式的类型。目前,表达式C()的类型是类C。但如果C::C()有返回类型R,那么表达式C()的类型应当是R,而不是C,于是便会引发上述的类型问题。
2、显式调用构造函数和析构函数
#include <iostream> using namespace std; class MyClass { public: MyClass() { cout << "Constructors" << endl; } ~MyClass() { cout << "Destructors" << endl; } }; int main() { MyClass* pMyClass = new MyClass; pMyClass->~MyClass(); delete pMyClass; return 0; }
结果:
Constructors
Destructors //这个是显示调用的析构函数
Destructors //这个是delete调用的析构函数
这有什么用?有时候,在对象的生命周期结束前,想先结束这个对象的时候就会派上用场了。直接调用析构函数并不释放对象所在的内存。
由此想到的:
new的时候,其实做了三件事,一是:调用::operator new分配所需内存。二是:调用构造函数。三是:返回指向新分配并构造的对象的指针。
delete的时候,做了两件事,一是:调用析构函数,二是:调用::operator delete释放内存。
所以推测构造函数也是可以显式调用的。做个实验:
int main()
{
MyClass* pMyClass = (MyClass*)malloc(sizeof(MyClass));
pMyClass->MyClass();
// …
}
编译pMyClass->MyClass()出错:
error C2273: 'function-style cast' : illegal as right side of '->'operator
它以为MyClass是这个类型。
解决办法有两个:
第一:pMyClass->MyClass::MyClass();
第二:new(pMyClass) MyClass();
第二种用法涉及C++ placement new 的用法。参考:http://www.cnblogs.com/luxiaoxun/archive/2012/08/10/2631812.html
显示调用构造函数有什么用?
有时候,你可能由于效率考虑要用到malloc去给类对象分配内存,因为malloc是不调用构造函数的,所以这个时候会派上用场了。
另外下面也是可以的,虽然内置类型没有构造函数。
int* i = (int*)malloc(sizeof(int));
new (i) int();
3、拷贝(复制)构造函数为什么不能用值传递
当你尝试着把拷贝构造函数写成值传递的时候,会发现编译都通不过,错误信息如下:
error: invalid constructor; you probably meant 'S (const S&)' (大致意思是:无效的构造函数,你应该写成。。。)
当编译错误的时候你就开始纠结了,为什么拷贝构造函数一定要使用引用传递呢,我上网查找了许多资料,大家的意思基本上都是说如果用值传递的话可能会产生死循环。编译器可能基于这样的原因不允许出现值传递的拷贝构造函数,也有可能是C++标准是这样规定的。
如果真是产生死循环这个原因的话,应该是这样子的:
class S { public: S(int x):a(x){ } S(const S st) //拷贝构造函数 { a = st.a; } private: int a; }; int main() { S s1(2); S s2(s1); return 0; }
当给s2初始化的时候调用了s2的拷贝构造函数,由于是值传递,系统会给形参st重新申请一段空间,然后调用自身的拷贝构造函数把s1的数据成员的值传给st。当调用自身的拷贝构造函数的时候又因为是值传递,所以...
也就是说,只要调用拷贝构造函数,就会重新申请一段空间,只要重新申请一段空间,就会调用拷贝构造函数,这样一直下去就形成了一个死循环。所以拷贝构造函数一定不能是值传递。
4、构造函数/析构函数抛出异常的问题
构造函数抛出异常:
1.不建议在构造函数中抛出异常;
2.构造函数抛出异常时,析构函数将不会被执行;
C++仅仅能删除被完全构造的对象(fully contructed objects),只有一个对象的构造函数完全运行完毕,这个对象才能被完全地构造。对象中的每个数据成员应该清理自己,如果构造函数抛出异常,对象的析构函数将不会运行。如果你的对象需要撤销一些已经做了的动作(如分配了内存,打开了一个文件,或者锁定了某个信号量),这些需要被撤销的动作必须被对象内部的一个数据成员记住处理。
析构函数抛出异常:
在有两种情况下会调用析构函数。第一种是在正常情况下删除一个对象,例如对象超出了作用域或被显式地delete。第二种是异常传递的堆栈辗转开解(stack-unwinding)过程中,由异常处理系统删除一个对象。
在上述两种情况下,调用析构函数时异常可能处于激活状态也可能没有处于激活状态。遗憾的是没有办法在析构函数内部区分出这两种情况。因此在写析构函数时你必须保守地假设有异常被激活,因为如果在一个异常被激活的同时,析构函数也抛出异常,并导致程序控制权转移到析构函数外,C++将调用terminate函数。这个函数的作用正如其名字所表示的:它终止你程序的运行,而且是立即终止,甚至连局部对象都没有被释放。
概括如下:
1.析构函数不应该抛出异常;
2.当析构函数中会有一些可能发生异常时,那么就必须要把这种可能发生的异常完全封装在析构函数内部,决不能让它抛出函数之外;
3.当处理另一个异常过程中,不要从析构函数抛出异常;
在构造函数和析构函数中防止资源泄漏的好方法就是使用smart point(智能指针),C++ STL提供了类模板auto_ptr,用auto_ptr对象代替原始指针,你将不再为堆对象不能被删除而担心,即使在抛出异常时,对象也能被及时删除。因为auto_ptr的析构函数使用的是单对象形式的delete,而不是delete [],所以auto_ptr不能用于指向对象数组的指针。当复制 auto_ptr 对象或者将它的值赋给其他 auto_ptr 对象的时候,将基础对象的所有权从原来的 auto_ptr 对象转给副本,原来的 auto_ptr 对象重置为未绑定状态。因此,不能将 auto_ptrs 存储在标准库容器类型中。如果要将智能指针作为STL容器的元素,可以使用Boost库里的shared_ptr。