Chapter 2 of Effective C++ （构造/析构/赋值运算）

条款05：了解C++默默编写并调用哪些函数
Know what functions C++ silently writes and calls

编译器会为空类生成一个copy构造函数、copy assignment操作符和一个析构函数。此外如果你没有声明任何构造函数，它也会生成一个默认构造函数。

（对C++11，应该是还会生成移动构造函数和移动赋值运算符。同时，当用户自定义移动构造函数，或移动赋值运算符，或拷贝构造函数，或拷贝赋值运算符，或析构函数时，编译器不会自动生成移动构造函数和移动赋值运算符）

这里延伸出来一个五法则：当你显式定义上述五个函数其中之一时，则需要同时显式定义其余四个。

默认生成的copy构造函数和copy assignment操作符只是单纯的将源对象中的每一个non-static成员变量拷贝到目标对象（浅拷贝）。

若一个类中存在const成员或引用成员，则不能使用默认生成的拷贝赋值操作符。

条款06：若不想使用编译器自动生成的函数，就该明确拒绝
Explicitly disallow the use of compiler-generated functions you do not want

假设一个类为 class HomeForSale {...}，我们不允许其拷贝。

HomeForSale h1;
HomeForSale h2;
HomeForSale h3(h1);    //企图拷贝h1，不该通过编译
h1 = h2;               //企图拷贝h2，也不该通过编译

方法一：

将拷贝构造函数和拷贝赋值操作符定义为private，并不实现它们。（编译器会阻止客户企图调用，连接器会阻止成员函数和友元函数的调用）

class HomeForSale{
public:
    ...
private:
    ...
    HomeForSale(const HomeForSale&)
    HomeForSale operator=(const HomeForSale&)
}

方法二：

继承一个Uncopyable接口，任何人尝试拷贝HomeForSale对象，编译器会尝试生成对应的拷贝构造函数和拷贝赋值操作符。这些函数的“编译器生成版”会尝试调用base class的对应兄弟，那些调用会被编译器拒绝，因为其是private（还可以将连接期错误移至编译期）

class Uncopyable{
protected:
    Uncopyable() {}
    ~Uncopyable() {}
private:
    Uncopyable(const Uncopyable&);
    Uncopyable& operator=(const Uncopyable&);
}

class HomeForSale: private Uncopyable{
    ...
};

方法三？：

好像这本书出版的时候c++11还没出来，所以没提到delete这个最简单的方法？

class HomeForSale{
public:
    ...
private:
    HomeForSale(const HomeForSale&) = delete
    HomeForSale operator=(const HomeForSale&) =delete
}

条款07：为多态基类声明 virtual 析构函数
Declare destructors virtual in polymorphic base classes

当derived class对象经由一个base指针被删除，而该base带着一个non-virtual析构函数，其结果未有定义 - 实际执行时通常发生的是对象的derived成分没被销毁。（解决方法是将base的析构函数声明为virtual）

任何class只要带有virtual函数都几乎确定应该也有一个virtual析构函数。

虚函数表主要存储的是指向一个类的虚函数地址的指针，通过使用虚函数表，继承、覆盖的问题都都得到了解决。假如一个类有虚函数，当我们构建这个类的实例时，将会额外分配一个指向该类虚函数表的指针，当我们用父类的指针来操作一个子类的时候，这个指向虚函数表的指针就派上用场了，它指明了此时应该使用哪个虚函数表，而虚函数表本身就像一个地图一样，为编译器指明了实际所应该调用的函数。

虚函数表会占内存，无端的将所有classes析构函数声明为virtual，就像从未声明它们为virtual一样，都是错误的。

继承一个“带有non-virtual析构函数”的class的问题和第一段一样，不会正确对derived class内存进行释放。

请记住：

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

条款08：别让异常逃离析构函数
Prevent exceptions from leaving destructors

C++并不禁止析构函数吐出异常，但它不鼓励你这样做。

class Widget {
public:
    ...
    ~Widget() {...}    //假设可能抛出异常
}

void doSomething()
{
    std::vector<Widget> v;
    ...
}

在析构vector第一个元素期间，有个异常被抛出，其他几个还是应该被销毁（否则它们保存的任何资源都会被泄露）。但如果第二个Widget析构函数又抛出异常，对于C++而言，在两个异常同时存在的情况下，程序若不是结束执行就是导致不明确行为。

但如果你的析构函数必须执行一个动作，该动作可能会在失败时抛出异常，该怎么办。

class DBConnection{
public:
    ...
    static DBConnection create();

    void close();
}

//为保证客户调用DBConnection的close，可以创建一个资源类来管理它，并在析构函数中调用close
class DBConn {
public:
    ...
    ~DBConn()
    {
        db.close();
    }
private:
    DBConnection db;
}

这便允许客户写出

{
    DBConn dbc(DBConnection::create());
}

但如果close调用导致异常（结束时,}）DBConn析构函数会传播该异常。因此需要避免这个问题。

方法一：close抛出异常就结束程序，调用abort（如果是一个遇到就无法继续执行的异常）

DBConn::~DBConn()
{
    try{db.close();}
    catch(...)
    {
        log();
        std::abort();
    }
}

方法二：吞下因调用close而发生的异常：

DBConn::~DBConn()
{
    try{db.close();}
    catch(...)
    {
        log();
    }
}

一个好一点的策略是，提供一个close函数给客户机会关闭连接。

class DBConn{
public:
    ...
    void close()
    {
        db.close();
        closed = true;
    }
    ~DBConn()
    {
        if (!closed)
        {
            try{db.close();}
            catch(...) { ... ;}
        }
    }
private:
    DBConnection db;
    bool closed;
}

请记住：

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

条款09：绝不在构造和析构函数中调用virtual函数
Never call virtual functions during construction or destruction

class Transaction{
public:
    Transaction();
    virtual void logTransaction() const = 0;
}

Transaction::Transaction()
{
    logTransaction();
}

class BuyTransaction: public Transaction{
public:
    virtual void logTransaction() const;
}

class SellTransaction: public Transaction{
public:
    virtual void logTransaction() const;
}

当构建一个BuyTransaction对象时，Transaction构造函数首先被调用，此时只会调用Transaction自己的log函数，而不是子类的（derived class对象的base class构造期间，对象是base class而不是derived class）。相同道理也适用于析构函数。

一个简单的方案可以解决这个问题。

class Transaction{
public:
    explicit Transaction(const std::string& logInfo);
    void logTransaction(const std::string& logInfo) const;
}

Transaction::Transaction(const std::string& logInfo)
{
    logTransaction(logInfo);
}

class BuyTransaction: public Transaction{
public:
    BuyTransaction(parameters) : Transaction(createLogString(parameters)) {}
private:
    static std::string createLogString(parameters);
}

请记住：
在构造和析构期间不要调用virtual函数，因为这类调用从不下降至derived class（比起当前执行构造函数和析构函数那层）

条款10：令operator=返回一个reference to *this
Have assignment operators return a reference to *this

int x, y, z;
x = y = z = 15; //等价于 x = (y = (z = 15));

为了实现”连锁赋值“，赋值操作符必须返回一个reference指向操作符的左侧实参，这是为classes实现赋值操作符应该遵循的协议。

class Widget{
public:
    Widget& operator=(const Widget& rhs)
    {
        ...
        return *this
    }
}

条款11：在operator=中处理“自我赋值”
Handle assignment to self in operator=

“自我赋值”发生在对象被赋值给自己时。

class Widget {...}
Widget w;
w = w;

a[i] = a[j]; //潜在的自我赋值
*px = *py;

当你尝试自行管理资源的时候，就要小心

class Bitmap {...};
class Widget {
private:
    Bitmap* pb;
}

Widget& Widget::operator=(const Widget& rhs)
{
    delete pb;
    pb = new Bitmap(*rhs.pb);
    return *this;
}

上述代码中，若*this和rhs是同一对象则会造成自己持有一个指针指向一个已被删除的对象。为阻止这种错误，传统方法为添加“证同测试”代码：

if (this = &rhs) return *this;

但这个版本的代码仍存在“异常安全性”的问题。如果"new Bitmap"异常，Widget最终会持有一个指针指向一块被删除的Bitmap，这样的指针有害，你无法安全的删除它们，甚至无法安全的读取它们。

Widget& Widget::operator=(const Widget& rhs)
{
    Bitmap* pOrig = pb;
    pb = new Bitmap(*rhs.pb);
    delete pOrig;
    return *this;
}

还有一种解决办法是使用copy and swap技术：

class Widget {
void swap(Widget& rhs);
};

Widget& Widget::operator=(const Widget& rhs)
{
    Widget temp(rhs);
    swap(temp);         //交换*this和rhs的数据，详见条款29
    return *this;
}

请记住：

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

条款12：复制对象时勿忘其每一个成分
Copy all parts of an object

class Customer{
public:
    Customer(const Customer& rhs);
    Customer& operator=(const Customer& rhs);
private:
    std::string name;
}

Customer::Customer(const Customer& rhs) : name(rhs.name) {}

Customer& operator=(const Customer& rhs)
{
    name= rhs.name;
    return *this;
}

上述代码一旦发生继承，可能会造成一个严重的潜藏危机。

class PriorityCustomer: public Customer{
public:
    PriorityCustomer(const PriorityCustomer& rhs);
    PriorityCustomer& operator=(const PriorityCustomer& rhs);
private:
    int priority;
}

PriorityCustomer::PriorityCustomer(const Customer& rhs) : priority(rhs.priority) {}

PriorityCustomer& operator=(const PriorityCustomer& rhs)
{
    priority= rhs.priority;
    return *this;
}

上述代码没有复制Customer的成员变量。因此，在为“derived class撰写copying函数”时，必须小心的复制其base class成分。

riorityCustomer::PriorityCustomer(const Customer& rhs) : Customer(ths), priority(rhs.priority) {}

PriorityCustomer& operator=(const PriorityCustomer& rhs)
{
    Customer::operator=(ths);
    priority= rhs.priority;
    return *this;
}

同时，请记住一个结论：不该令copy assignment操作符调用copy构造函数，也不该令copy构造函数调用copy assignment操作符。

如果发现copy构造函数和copy assignment操作符有相近代码，正确做法是建立一个新的成员函数给两者调用。这样的函数往往是private且常被命名为init。

请记住：

• Copying函数应该确保复制“对象内所有成员变量”和“所有base class成分”。
• 不该令copy assignment操作符调用copy构造函数，也不该令copy构造函数调用copy assignment操作符。