《effective c++》学习笔记（二）

了解C++默默编写并调用哪些函数

对于一个类来说，编译器会暗自创建default构造函数、copy构造函数、copy assignment操作符、析构函数。

这些copying函数会再执行每一个成员的copying函数。

所以当我们拷贝带有指针的类时，要考虑是拷贝指针所指之物还是拷贝指针本身。

• 编译器可以暗自为class创建default构造函数、copy构造函数、copy assignment操作符，以及析构函数

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

假如当我们不想让该类拥有拷贝函数时，就该让该拷贝函数声明为private权限（c++0x），对于c++11，我们可以使用delete关键字：

 class Foo {    Foo& operator=(const Foo& rhs) = delete;};

• 为驳回编译器自动提供的机能，可将相应的成员函数声明为private并且不予实现。使用像Uncopyable这样的base class也是一种做法。（c++11后可以使用delete关键字）

为多态基类声明virtual析构函数

考虑下面这个例子：

class Base {public:    Base() : p(new int) {        cout << "Base::constructor" << endl;    }    ~Base() {        cout << "Base::destructor" << endl;        delete p;    }private:    int *p;};class Derived : public Base{public:    Derived() : pp(new int) {        cout << "Derived::constructor" << endl;    }    ~Derived() {        cout << "Derived::destructor" << endl;        delete pp;    }private:    int *pp;};int main() {    Base *b = new Derived;    delete b;    return 0;}//输出Base::constructorDerived::constructorBase::destructor

当b构造时，会调用Derived和Base的构造函数，但当b析构的时候，仅仅会调用Base的析构函数，并不会调用Derived的析构函数。

因为Base的析构函数不是虚函数，所以当b析构的时候，不会调用到Derived的析构函数，所以造成了Derived内的资源无法得到释放，造成内存泄漏等很难发现的错误。

如果要编写一个non-virtual析构函数的类，那么要声明为final（c++11）来禁止其他类继承。

• 带多态性质的base classes应该声明一个virtual析构函数。如果class带有任何virtual函数，它就应该拥有一个virtual析构函数
• Classes设计目的如果不是作为base classes使用，或不是为了具备多态性，就不该声明virtual析构函数

别让异常逃离析构函数

考虑下面这个例子：

class Foo {public:    ~Foo() {        // something        // 可能会抛出异常    }};int main() {    vector<Foo> vec;    // something    return 0;}

那么当vector析构的时，会销毁每一个Foo对象，假设第一个Foo对象析构的时候抛出了异常，那么剩余9个将无法析构，此时造成了内存泄漏。

合适的做法是，当析构函数有可能出现异常时，使用try…catch吞下这个异常，或者直接终止程序。或者提供一个成员函数，让用户自己来销毁类中的资源，最后再在析构函数中再进行一次判断（此时又回到了吞下异常或直接终止程序上了）。

• 析构函数绝对不要吐出异常。如果一个被析构函数调用的函数可能抛出异常，析构函数应该捕捉任何异常，然后吞下它们（不传播）或结束程序
• 如果客户需要对某个操作函数运行期间抛出的异常做出反应，那么class应该提供一个普通函数（而非在析构函数中）执行该操作

绝不在构造和析构函数中调用virtual函数

考虑下面这份代码：

class Base {public:    Base() {        init(); // 期望调用Derived::init    }    virtual void init();};class Derived : public Base {public:    Derived() {        init();    }    virtual void init();};

上面这份代码中，Base的构造函数期望调用Derived::init函数（因为init是虚函数），但并不会发生。因为this指针在构造Base中的成员时，会无视virtual函数。

原因很简单，因为Base中的成员会先与Derived构造，在构造Base部分时，Derived中的部分还是未初始化状态，为了安全考虑，在构造Base部分时，会完全无视Derived部分，仿佛就只有一个Base class一样。

析构函数也是同理，在析构Base部分时，Derived部分已经被析构，所以Base部分不会再调用Derived部分的任何东西。

• 在构造和析构期间不要调用virtual函数，因为这类调用从不下降至Derived class

令operator=返回一个reference to *this

原因很简单，为了和c++内置类型保持一致性，所以我们最好让operator=返回一个reference，来实现例如下面这份代码的功能：

Foo a;Foo b;Foo c;a = b = c;(a = b) = c;

• 令赋值操作符返回一个reference to *this

在operator=中处理“自我赋值”

考虑下面这份代码：

class Foo {public:    Foo &operator=(const Foo& rhs) {        delete[] arr;        arr = new int[rhs.len];        for (int i = 0;i < len;++i) {            arr[i] = rhs.arr[i];        }        return *this;    }private:    int *arr;    int len;};

当我们执行Foo a; a = a;时，会发生这样一种情况：a先把自身的资源释放了，再申请这么多资源，再一个一个的进行int的自我赋值。最终的效果则是，a被赋值后，数组中所有的值都丢失了，并且被替换为垃圾值。

这是因为没有很好的处理自我赋值，处理自我赋值有两种方案，一种是在函数的最前面直接判断赋值符左右两个对象的地址，如果一样那么就是自我赋值：

Foo &operator=(const Foo& rhs) {    if (this == &rhs0) {        return *this;    }    delete[] arr;    arr = new int[rhs.len];    for (int i = 0;i < len;++i) {        arr[i] = rhs.arr[i];    }    return *this;}

但这样仍然会有“异常安全性”问题，假如new操作符抛出了异常，那么此时arr的值是未定义的。

第二种方法是使用copy and swap技巧，可以同时解决“自我赋值”和“异常安全性”问题，思想是将赋值符右边的对象先拷贝到临时对象一份，然后再交换临时对象和this对象。

Foo &operator=(const Foo& rhs) {    if (this == &rhs) {        return *this;    }    Foo tmp(rhs);    swap(*this, tmp);    return *this;}

但这样做，需要要考虑swap的种种问题，这会在以后讨论。

• 确保当对象自我赋值时operator=有良好的行为。其中技术包括比较“来源对象”和“目标对象”的地址、精心周到的语句顺序、以及copy-and-swap
• 确定任何函数如果操作一个以上的对象，而其中多个对象是同一个对象时，其行为仍然正确

赋值对象时勿忘其每一个成分

当编写一个copying函数时，要记得（1）copy对象中的每个成员（2）拷贝Base部分的每个成员。

其中（1）往往能被我们记住，而（2）通常会忘记显式调用Base的operator=。

class Base {public:    Base &operator=(const Base &rhs) {        a = rhs.a;    }private:    int a;};class Derived {public:    Derived &operator=(const Derived &rhs) {        Base::operator=(rhs);        b = rhs.b;    }private:    int b;};

• Copying函数应该确保复制“对象内的所有成员变量”及所有“Base class成分”
• 不要尝试以某个copying函数实现另一个copying函数。应该将共同机能放进第三个函数中，并由两个copying函数共同调用。