EC之Constructors,Destructors, and Assignment Operators

条款05：Know what function C++ silently writes and calls

如果没有显式声明，编译器会自动为class创建default构造函数、copy构造函数、copy assignm操作符以及析构函数。显式声明这些函数或在base class中将这些函数声明为private可以阻止编译器的这一行为。

如果class内含const或reference成员，那么编译器将拒绝为其自动生成copy assignment操作符。

条款06：Explicitly disallow the use of compiler-generated functions you do not want

如果你想阻止class的copying行为，你可以将copy构造函数和copy assignment操作符声明为private，同时不提供定义，这正是标准库iostream的做法。

考虑如下类：

class Unique {
public:
  ...
  Unique() {}
  ~Unique() {}
private:
  ...
  Unique(const Unique&);            //只有声明
  Unique& operator=(const Unique&);
};

当用户试图拷贝该类的对象时，编译器就会报错；如果在member函数或friend函数中这么做，链接器会报错。

将链接期错误移至编译期可以尽早检测到错误。为此，我们需要一个专门为了阻止copying行为而设计的base class：

class Uncopyable {
protected:
  Uncopyable() {}            //允许derived对象构造和析构
  ~Uncopyable() {}
private:
  Uncopyable(const Uncopyable&);        //但阻止copying
  Uncopyable& operator=(const Uncopyable&);
};

为阻止class C的对象被拷贝，我们只需让C继承Uncopyable：

class C : private Uncopyable {
...                             //不要声明copy构造函数或copy assignment操作符
};

在class C内我们不再声明copy构造函数和copy assignment操作符，于是编译器就会尝试自己合成它们，但由于其无权调用base class的对应版本，结果只能以失败告终。

条款07：Declare destructors virtual in polymorphic base classes

如果多态基类的析构函数是non-virtual的，那么析构函数将静态绑定，我们就不能经由一个base class指针删除一个derived对象。若这么做，结果未定义——通常发生的是对象的derived成分没被销毁。任何class只要带有virtual函数都几乎确定该有一个virtual析构函数。

Pure virtual函数导致abstract classes，也就是不能被实例化的class。有时候你希望有一个抽象class，但手上没有任何pure virtual函数，这时可以创建一个pure virtual析构函数。

class AWOV {     // AWOV = "Abstract w/o Virtuals"
public:
  virtual ~AWOV() = 0;
};

然而，你必须为pure virtual析构函数提供一份定义：

AWOV::~AWOV() {}   // 如果不提供定义，链接器将会报错

这是因为AWOV的derived class的析构函数将调用AWOV的析构函数。若不提供定义，链接目标文件时将出错。

条款08：Prevent exceptions from leaving destructors

绝对不要在析构函数中吐出异常。如果一个被析构函数调用的函数可能抛出异常，析构函数应该捕捉任何异常，然后屯下它们或结束程序。

如果客户需要对某个操作函数运行期间抛出的异常做出反应，那么class应该提供一个普通函数（而非在析构函数中）执行该操作。

条款09：Never call virtual functions during construction or destruction

#include <iostream>

class Base {
public:
  Base() {
    init();
  }
  virtual void init() {
    std::cout << "base constructor." << std::endl;
  }
  virtual void clean() {
    std::cout << "base destructor." << std::endl;
  }
  ~Base() {
    clean();
  }
};

class Derived : public Base {
public:
  virtual void init() {
    std::cout << "derived constructor." << std::endl;
  }
  virtual void clean() {
    std::cout << "derived destructor." << std::endl;
  }
};

int main() {
  Derived d;
}

程序运行后输出：

base constructor.
base destructor.

可能并不是你想要的结果。这是因为derived class对象在构造base class成分时，它的类型还只是base class，因此调用的virtual函数版本也是base class的。

条款10：Have assignment operators return a reference to *this

书上说，为了实现连锁赋值，赋值操作符必须返回一个reference指向操作符的左侧实参。但是测试发现，就算不返回reference也能实现连锁赋值。

class Integer {
public:
  Integer(int value = 0) : value(value) {}
  Integer operator=(const Integer &rhs) {
    value = rhs.value;
    return *this;
  }
  void print() {
    std::cout << value << std::endl;
  }
private:
  int value;
};

int main() {
  Integer x(1), y(2), z(3);
  x = y = z;
  x.print();   //输出3
}

当然，即便如此，我们还是应该令operator=返回一个reference，无疑这样的效率最高。我想这才是所有内置类型和标准库类型遵守这个原则的真正原因吧。

条款11：Handle assignment to self in operator=

自我赋值发生在对象被赋值给自己时：

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

这看起来有点愚蠢，但却是合法的，不要认定客户不会这么做。

还有一些自我赋值不那么明显，如：

a[i] = a[j];   //若i == j，则为潜在的自我赋值

*px = *py;   //若px和py指向同一对象，则为潜在的自我赋值

事实上，别名（包括指针和引用）使得指涉一个对象的方法不只一个，大大增加了自我赋值的可能性。特别是在继承体系中，base class的指针或引用可以指向一个derived

class对象，两个对象甚至不需要声明为相同类型就可能造成别名。

考虑如下类：

class Text {
public:
  Text(const char *ps);
  Text(const Text &rhs);
  Text& operator=(const Text &rhs);
  ~Text();
  std::string toString() const;
private:
  char *ps;
};

Text::Text(const char *ps) {
  this->ps = new char[strlen(ps) + 1];
  strcpy(this->ps, ps);
}

Text::Text(const Text &rhs) {
  ps = new char[strlen(rhs.ps) + 1];
  strcpy(ps, rhs.ps);
}

Text&
Text::operator=(const Text &rhs) {
  delete []ps;
  ps = new char[strlen(rhs.ps) + 1];
  strcpy(ps, rhs.ps);
  return *this;
}

Text::~Text() {
  delete []ps;
}

std::string Text::toString() const {
  return std::string(ps);
}

Text对象在进行自我赋值时出现的问题很明显，strlen的调用将以一个以销毁的字符串为实参，更不用说之后的一系列操作了。避免这种错误最简单的方法是进行identity test：

Text&
Text::operator=(const Text &rhs) {
  if (this == &rhs) return *this;

  delete []ps;
  ps = new char[strlen(rhs.ps) + 1];
  strcpy(ps, rhs.ps);
  return *this;
}

这样，修改后的operator=已经获得了“自我赋值安全性”，但它仍不具备“异常安全性”。具体来讲，当new操作失败时，Text最终会持有一个指向被删除的字符串的指针。

幸运的是，具有“异常安全性”的operator=往往具有“自我赋值安全性”，因此，我们只需将焦点放在实现“异常安全性”上。

Text&
Text::operator=(const Text &rhs) {
  char *pOrg1 = ps, *pOrg2 = rhs.ps;
  ps = new char[strlen(rhs.ps) + 1];
  strcpy(ps, pOrg2);
  delete []pOrg1;
  return *this;
}

这里我们用了两个指针来记录原来的ps和rhs.ps，pOrg1是为了最后能删除原来的ps，pOrg2是为了发生自我赋值时strcpy能获取原来的rhs.ps。

往往一组精心组织的语句可以帮我们实现“异常安全性”，除此之外，我们还可以使用所谓的copy and swap技术，其基本做法是：为要修改的对象创建一个副本，然后在副本上进行修改，最后交换副本和原对象的数据。这样，即使修改过程中抛出了异常，原对象仍可以保持不变。

首先为Text类添加一个swap成员函数：

void Text::swap(Text &rhs) {
  std::swap(ps, rhs.ps);
}

然后利用它实现operator=：

Text&
Text::operator=(const Text &rhs) {
  Text temp(rhs);
  swap(temp);
  return *this;
}

总结：确保“自我赋值安全性”的方法有三种，分别是测试操作数，精心组织语句以及copy and swap技术。其中后两种方法同时实现了“异常安全性”。特别是copy and swap技术，不仅代码简洁，而且逻辑清晰，非常值得学习。

条款12：Copy all parts of an object

Copying函数应该确保复制对象内的所有成员变量以及所有base class成分。