二、构造/析构/赋值运算
条款05:了解 C++ 默默编写并调用了哪些函数
在创建类时,如果自己不定义默认构造,拷贝构造(拷贝运算符),析构函数,那么编译器会自动生成这些函数。
//拷贝运算符: classname& operator=(const classname& cn){......}
但是有些情况下编译器不会自动生成,拿下面这段代码举例:
可以发现由于 class 里出现了引用类型和 const 类型,故编译器就不会自动生成拷贝复制和移动赋值函数。
这是因为引用类型是引用其他地方的内容,如果调用拷贝赋值和移动赋值可能会顺带改变引用处的值。
而 const 类型本身就是不可改动的,所以不会生成拷贝赋值和移动赋值函数。
另外 mutex 本身不能被拷贝和移动,所以拷贝构造和移动构造函数也不会自动生成。
条款06:若不想使用编译器自动生成的函数,就应该明确拒绝
对于类中拷贝构造函数,我们应当阻止他们。但若是不声明,编译器也会自动生成拷贝构造函数。
在现代 c++ 中我们可以通过 delete 关键字对编译器自动生成的函数进行删除,如下图所示:
但在之前的 C++ 中并没有该关键字,所以可以用私有化的方式进行。
class person { private: person(const person&); person& operator=(const person&); //参数是不必要写的,毕竟这个函数不会被实现 public: ...... };
编译器自动生成的函数都是 public 函数,所以我们将 public 改为 private,就可以防止对象调用拷贝构造。
注:private 只有成员函数和友元函数可以调用。
同时也产生了一个问题,如何防止拷贝在成员函数或友元函数中被调用?
答案是建立一个父类,在父类中定义 private 拷贝函数,子类( person 等等)继承父类。因为子类不可以调用父类的 private 函数:
class uncopyable { private: uncopyable(const uncopyable&); uncopyable operator=(const uncopyable&); }; class person{......};
条款07:为多态基类声明virtual析构函数
多态把父类当作一个接口,用以处理子类对象:利用父类指针,指向一个在堆区开辟的子类对象。
class person { public: person(); ...... ~person(); }; class teacher: public person{......}; person* p = new teacher(...); ... delete p; //在堆区开辟的数据要手动删除
上述代码是有问题的。
我们知道,在普通类继承里,删除子类对象会先调用子类的析构,再调用父类的析构。但在多态里情况有所不同。我们删除的是父类指针,调用的只是父类的析构函数,子类析构不会被调用,也就是说,子类对象没有被删除,而指针却没了。这是局部销毁,会造成资源泄漏等错误。
幸运的是,我们可以通过虚函数来解决这个问题。
在多态里,虚函数可以让子类重写父类的函数,同时在虚函数表中生成一个指针,找到子类重写函数的地址,从而让我们可以通过父类访问子类重写的函数。
class person { public: person(); ...... virtual ~person(); }; class teacher: public person{......}; person* p = new teacher(...); ... delete p; //删除 p 的时候调用 virtual ~person(); //virtual 找到子类析构函数的地址,导致子类也可以被删除
纯虚函数使得父类更像一个接口,这里不用多说。
注:多态里父类应该至少有一个虚函数(virtual 析构),若不用做多态,则类里不应该有虚函数。
条款08:别让异常逃离析构函数
释义:在析构函数内部处理异常
我们来看以下案例:
如果在 db.close() 处发生异常,则会导致不可预料的情况。
首先介绍一下异常处理的办法:
try {...} //try 内部写可能产生异常的语句,没有产生异常,则catch语句不执行,产生则一一匹配 //catch 用于捕获并处理异常,和 case 有异曲同工之妙 catch(...) { 1、可以使用 abort(); 函数终止程序 2、可以吞下这个异常,在 catch 内部做一些处理 }
了解如何处理异常之后,我们就可以实现如条款所说,在析构函数内部处理异常:
上面左边的方法是直接调用 abort 终止程序,右边则是直接吞下异常,只是记录个日志,后面再处理。
但是这两种方法都有个缺点就是用户无法参与操作,因此可以写成下面的方式:
用户可以自己实现一个 close 函数来进行关闭,如果关闭的顺利则 closed=true,反之关闭失败则会进行异常捕捉,在析构函数中帮助用户关闭。
条款09:绝不在构造和析构函数中使用虚函数
众所周知,在类的操作中,父类比子类先构造,而子类也比父类先析构(多态也是如此,多态先通过 virtual 找到子类析构,再析构父类),所以在构造父类的时候,子类对象还未进行初始化,在析构父类的时候,子类已经被销毁。来看下面这个例子:
此时,如果父类的构造和析构函数中有 virtual,则该函数无法找到子类的地址(或者说无视子类,因为子类被销毁/未被初始化),使程序发生不明确的行为。
可以发现上面我是想调用派生类的构造函数和析构函数,但是调用的却是基类的。如果想满足该要求,我们可以去掉虚函数,而是在基类接收一个参数来实现。
条款10:令 operator= 返回一个 reference to *this
释义:让赋值运算符重载版本返回一个自身,以便实现链式编程。
class employee{ public: int m_salary; employee(int a)//有参构造,赋工资初值 { this->m_salary = a; } employee& operator=(const employee& ep) { this->m_salary = ep.m_salary; return *this; } //返回其本身 }; employee e1(5000); employee e2(50000); employee e3(123456); e1 = e2 = e3; //链式编程
条款11:在 operator= 中处理自我赋值
我们来看一段代码:
class person{...}; person p; p = p;
这是自我赋值,这种操作看起来有点愚蠢,但是并不很难发生。
比如,一个对象可以有很多种别名,客户不经意间让这些别名相等;
或者如之前所说,父类的指针/引用指向子类的对象,也会造成一些自我赋值的问题。
自我赋值往往没有什么意义,还会有不安全性。
class student{...}; class teacher { ... private: student* s; }; teacher& teacher::operator=(const teacher& teach) { if(s != NULL) { delete s; s = NULL; } s = new student(*teach.s); return *this;//便于链式操作 }
上述代码是不安全的。如果 *this 和 teach 是同一个对象,那么客户在删除 *this 的时候,也把 teach 删除了,s 就会指向一个被删除的对象,这是不允许的。
我们提供三种方法以解决这个问题:
1、证同检测:
teacher& teacher::operator=(const teacher& teach) { if (this == &teach) return *this; //证同检测 if (s != NULL) { delete s; s = NULL; } s = new student(*teach.s); return *this;//便于链式操作 }
遗憾的是,证同检测可以保证自我赋值的安全性,但是不能保证“异常安全性”。即,如果 new student 抛出异常,则 s 就会指向一个被删除的对象,这是一个有害指针,我们无法删除,甚至无法安全读取它。
2、记住原指针:
teacher& teacher::operator=(const teacher& teach) { student* stu = s; //记住原指针 if(s != NULL) { delete s; s = NULL; } s = new student(*teach.s); //如果抛出异常,s 也可以找回原来地址 delete stu; //删除指针 return *this;//便于链式操作 }
3、copy and swap:
void swap(const teacher& teach) {......} teacher& teacher::operator=(const teacher& teach) { teacher temp(teach); //拷贝一个副本 swap(temp); //将副本和 *this 交换 return *this;//便于链式操作 }
交换操作不要考虑原本指针内容,可以保证赋值安全性,同时也能保证异常安全性。
条款12:复制对象时勿忘其每一个成分
释义:自定义拷贝函数时,要把类变量写全(子类拷贝不要遗漏父类的变量)。
父类变量通常存储在 private 里,子类不能访问父类 private 对象,所以应该调用父类的构造函数。
class animal { public: animal(const animal& an) {......} animal& opeartor=(const animal& an) {......} ...... private: string typename; }; class cat: public animal { public: cat(const cat& c); cat& operator=(const cat& c); private: string cat_type; }; cat::cat(const cat& c) :cat_type(c.cat_type), //为了不遗漏父类变量,调用父类函数 animal(c) {} cat::cat& operator=(const cat& c) { //为了不遗漏父类变量,调用父类函数 animal::operator=(c); this->cat_type = c.cat_type; return *this; }
值得注意的是,上面代码 copy 函数和 “=” 运算符调用的都是和本身一样的函数。究其原因,copy 函数是创建一个新的对象,operator= 是对已经初始化的对象进行操作。
我们不能用 copy 调用 operator=,因为这相当于用构造函数初始化一个新对象(父类尚未构造好)。
同理,也不能用 operator= 调用 copy,这相当于构造一个已经存在的对象(父类已经存在了)。