Effective C++读书笔记2(构造/析构/赋值运算)

◆条款05： 了解C++默默编写并调用哪些函数

一个像这样的空类：

1. class Empty {
2. };

C++编译器就会声明一个拷贝构造函数、一个拷贝赋值函数和一个析构函数，如果你没有声明任何构造函数，编译器也会自动添加一个默认构造函数，如下：

1. class Empty {
2. public:
4.     Empty() { ... }                             // 默认构造函数
5.     
6.     Empty(const Empty& rhs) { ... }             // 拷贝构造函数
8.     ~Empty() { ... }                            // 析构函数
10.     Empty& operator=(const Empty& rhs) { ... }  // 拷贝赋值函数
12. };

注： 如果该类含有一个引用类型的成员变量或const类型的成员变量，编译器无法生成拷贝赋值函数，还有一种情况就是如果基类的拷贝赋值函数为private，编译器也无法为派生类生成拷贝赋值函数。

 

◆条款06： 若不想使用编译器自动生成的函数，就该明确拒绝

如果我不想类之间的对象能互相拷贝，有两种方法：

1. class Test {
2. public:
4.     ...
6. private:
8.     Test(const Test&);           // 只有声明没有定义
9.     Test& operator=(const Test&);
11. };

这个方法可以归结为一句话： 将成员函数声明为private而且故意不实现它们。成员函数和友元函数不慎调用的时候，也会因为没有实现而报链接错误。

这种方法可能不是很完美，因为有时会将错误推迟到链接阶段，还有一种方法：

1. class Uncopyable { 
2. protected: 
3.     // 允许派生对象构造和析构 
4.     Uncopyable()  { } 
5.     ~Uncopyable() { }
7. private:
8.     // 阻止拷贝
9.     Uncopyable(const Uncopyable&);
10.     Uncopyable& operator=(const Uncopyable&);
11. };
13. class Test: private Uncopyable {
14.    ...
15. };

Boost库中有一个类似的类可以提供这样的功能： noncopyable

 

◆条款07： 为多态基类声明virtual析构函数

为那些预备作多态用的基类声明virtual析构函数，如果不这样的话，派生类析构的时候只调用基类的析构函数，而不会调用派生类自己的析构函数。如果一个类有任何virtual函数，就应该有一个virutal析构函数。

注： 当且仅当是基类且是为了多态用时才必须遵守。

 

◆条款08： 别让异常逃离析构函数

析构函数不能抛出异常，因为无法确定会让异常抛到哪一层，尽量封装这些能抛出异常的代码成一个用户手工调用的成员函数，在析构函数里只做最后一层保险，截获该异常。

 

◆条款09： 绝不在构造和析构过程中调用virtual函数

构造和析构时调用的virtual函数只是基类的函数，不是派生类的函数。

 

◆条款10： 令operator=返回一个reference to *this

任何赋值成员函数必须返回*this，如：

1. class Widget {
2. public:
3.     
4.     ...
5.   
6.     Widget& operator=(const Widget& rhs) {
7.         ...
8.         return *this;
9.     }
11.     ...
12. };

◆条款11： 在operator=中处理“自我赋值”

赋值时并不确定赋值的两方是不是同一对象，如果无视这个而直接进行下一步的赋值工作，很可能会由于使用刚刚被删除的内存而引起访问一个已被删除的对象的问题，所以一般要进行一个比较是否是同一对象的步骤再接着处理。如：

1. class Bitmap { ... };
3. class Widget {
4.     ...
5. private:
6.     Bitmap* pb;
7. };
9. Widget& Widget::operator=(const Widget& rhs)
10. {
11.     // 如果没这一步的话很可能出现rhs被删除后又调用rhs.pb的情况
12.     if(this == &rhs) return *this;
14.     delete pb;
15.     pb = new Bitmap(*rhs.pb);
16.     return *this;
17. }

也可以不比较而通过保存旧对象最后成功处理后再删除的方法，可能效率要稍微低一点，因为做了无用的操作。

1. Widget& Widget::operator=(const Widget& rhs)
2. {
3.     Bitmap* pOrig = pb;
4.     pb = new Bitmap(*rhs.pb);
5.     delete pOrig;
6.     return *this;
7. }

不过可以再添加一个比较的分支来处理自我赋值，就是这样写好像有点太难看了。

 

◆条款12： 复制对象时勿忘其每一个成分

如果你要实现自己的拷贝构造函数和拷贝赋值函数，那你就必须确保你的对象里的每一个成员变量都要被复制，包括基类的成员变量。