【Effective C++】构造/析构/赋值运算
几乎你写的每一个class都会有一个或多个构造函数、一个析构函数，一个copy assignment操作符。如果这些函数犯错，会导致深远且令人不愉快的后果，遍及你的整个classes。所以确保它们行为正确时生死攸关的大事。本章提供的引导可让你把这些函数良好地集结在一起，形成classes的脊柱。
条款05：了解C++默默编写并调用哪些函数
如果你自己没有声明，编译器就会声明
- 默认构造函数
- copy构造函数 //单纯地将来源对象的每一个non-static成员变量拷贝到目标对象
- copy assignment操作符 //同上
- 析构函数 //是个non-virtual
唯有这些函数被需要（被调用），它们才会被编译器创建出来，下面代码造成上述每一个函数被编译器产出：
Empty e1; //默认构造函数 //析构函数 Empty e2(e1); //拷贝构造函数 e2=e1; //copy assignment操作符
注意：
如果生成的代码不合法或者没有意义时，编译器会拒绝为class生成operate=：
（1）不合法
#include <string> #include <iostream> using namespace std; class Dog { public: Dog(string& namevalue, int agevalue):name(namevalue),age(agevalue){ //name = namevalue; 当需要初始化const修饰的类成员/引用成员数据应使用成员初始化列表 //age = agevalue; } void show() { cout << name << " is " << age << " years old." << endl; } private: string& name; const int age; }; int main() { string s1("Persephone"); string s2("Satch"); Dog d1(s1, 2); Dog d2(s2, 36); //Dog d1("Persephone", 2); //Dog d2("Satch", 36); //d1 = d2;//无法引用 函数 "Dog::operator=(const Dog &)" (已隐式声明) -- 它是已删除的函数
d1.show();
d2.show();
getchar();
}
由于C++不允许“让引用改指向不同的对象”，编译器没有自动生成operate=，d1=d2就会报错。
（2）没有意义
如果某个base classes将copy assignment操作符声明为private，编译器将拒绝为其derived classes生成一个copy assignment操作符。毕竟编译器为derived classes所生的copy assignment操作想象中可以处理base class成分（条款12）。
条款06：若不想使用编译器自动生成的函数，就应该明确拒绝
有些类，你不想它的对象被拷贝，但如果你不声明拷贝构造函数，编译器会自动给你生成。这时候我们可以，
1）将拷贝构造函数和copy assignment操作符声明为private（此时member函数和friend函数还是可以调用你的private函数），并且不去定义它。
2）写一个base class，它有私有的拷贝构造函数和copy assignment操作符，然后去继承它，根据上一条，编译器将拒绝为其生成一个copy assignment操作符。（可能会导致多重继承
3）使用Boost提供的版本。（还没学到
条款07：为多态基类声明virtual析构函数
比如在使用工厂函数时，工厂函数会返回一个base class指针，指向新生成的derived对象。被返回的对象位于heap，因此为了避免泄露内存和其他资源，需要delete该对象。
BasicCamera* pb = CreateCamera()； ... delete pb;
指针指向的时子类对象，但却经由一个base class指针来删除，而目前的base class有一个non-virtual析构函数（条款05指出，编译器自动生成的析构函数是non-virtual的）。这会引来灾难，因为实际执行时，通常发生的是，对象的derived成分没被销毁，base class成分通常会被销毁，造成一个局部销毁的对象。
解决方法：
给base class一个virtual析构函数
注意：
- 任何class只要带有virtual函数都几乎确定应该也有一个virtual析构函数。
- 如果class不含virtual函数，通常表示它不意图被用作一个base class，此时令其析构函数为virtual，会导致其对象的体积增大，不能传递至其他语言的函数。
- 总而言之，只有当class内含至少一个virtual函数，才为它声明virtual析构函数
- 有时候抽象类不想被实体化，比如说BasicCamera创建对象没有意义，你可以有一个pure virtual函数，这时候可以声明一个pure virtual的析构函数。
class BasicCamera { public: virtual ~BasicCamera() = 0; };
加上virtual，加上“=0”，就成为pure virtual函数了，但是书上说“必须为这个pure virtual析构函数提供一份定义”？？？由子类继承后定义可以吗？
试了一下，好像确实如此。
#include<iostream> using namespace std; class BasicCamera { public: virtual ~BasicCamera()=0;//如果此处为~BasicCamera()，只会调用父类的析构 }; BasicCamera::~BasicCamera() { cout << "调用了BasicCamera的析构函数" << endl; }//不加会报错，必须要定义 class Hik :public BasicCamera { public: ~Hik() { cout << "调用了hik的析构函数" << endl; } }; class Factory { public: BasicCamera* CreateCamera() { return new Hik(); } }; int main() { Factory fac = Factory(); BasicCamera* camera = fac.CreateCamera(); delete camera; getchar(); return 0; }
运行结果：
可以看出，析构函数的运作方式是，最深层派生的那个class（此处为子类hik）的那个析构函数最先被调用，然后是每一个base class的析构函数被调用。编译器会在子类的析构函数中调用父类的析构函数，所以必须提供一份定义。
条款08：别让异常逃离析构函数
如果析构函数吐出异常程序可能过早结束或出现不明确行为。比如，HikCamera类在析构时抛出异常：
#include<iostream> using namespace std; class HikCamera { public: ~HikCamera() { throw 1; closed = true; } private: bool closed = false; }; int main() { { HikCamera cam; } getchar(); return 0; }
上图可以看出，调用了abort函数终止了程序。但如果析构函数必须执行一个动作，而该动作可能会在失败时抛出异常，该怎么办？
1. 如果抛出异常就结束程序（通常通过abort完成）：
~HikCamera() { try { throw 1; closed = true; } catch (int i) { abort(); } }
如果程序遭遇一个“于析构期间发生的错误”后无法继续执行，“强迫结束程序”是个合理选项。毕竟它可以阻止异常从析构函数传播出去（那会导致不明确的行为）。也就是说调用abort可以抢先置“不明确行为”于死地。
2.吞下因调用close而引发的异常
~HikCamera() { try { throw 1; closed = true;} catch (int i) { cout << "close函数中有异常" << endl; } }
3. 将异常放在析构函数之外
提供一个close函数，赋予客户机会对可能出现的问题作出反应。同时可以在析构函数中追踪，由析构函数关闭之。
class HikCamera { public: void close() { throw 1; closed = true; } ~HikCamera() { if(!closed){ try { close(); } catch (int i) { cout << "close函数中有异常" << endl; }} } private: bool closed = false; };
条款09：绝不在构造和析构过程中调用virtual函数
假如在构造函数中调用了virtual函数：
class BasicCamera { public: BasicCamera() { open();//调用了virtual函数 } virtual void open() { cout << "打开了相机" << endl; } }; class HikCamera:BasicCamera{ public: HikCamera() { cout << "创建了hik相机" << endl; } void open() { cout << "打开了海康相机" << endl; } };
运行结果：
在创建子类对象时，不会创建父类对象，只是初始化子类中属于父类的成员。父类的构造函数会被调用，运行父类构造函数时，里面的父类版本的virtual函数被调用了，不是子类中的版本。
原因
1. 当基类的构造函数执行时，子类的成员变量尚未初始化，如果virtual函数（open函数）调用了子类成员变量，这会导致不明确行为。
2. 基类构造期间，对象类型为基类。不只是virtual函数被编译器解析至基类，若使用运行期类型信息，也会把对象视为基类。
同样的道理也适用于析构函数。一旦子类的析构函数开始执行，子类成员变量就会呈现未定义值，进入基类析构函数后对象成为基类对象。
想要确保每一次有子类被建立就调用对应的open()，
解决方法
把父类的virtual函数改为不virtual的，然后子类的构造函数传递必要信息给父类的构造函数，父类的构造函数就可以调用non-virtual的open()了。像这样：
#include<iostream> using namespace std; class BasicCamera { public: BasicCamera(const string& info) { open(info); } void open(const string& info) { cout << "打开了" << info << "相机" << endl; }; }; class HikCamera:BasicCamera{ public: HikCamera(string s):BasicCamera(s) { } }; int main() { HikCamera cam("Hik"); getchar(); return 0; }
换句话说，无法使用virtual函数从基类向下调用，在构造期间，你可以“令子类将必要的构造信息向上传递至基类构造函数”。
条款10：令operate=返回一个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) //返回类型是一个reference，指向当前的对象 { ... return* this; //返回左侧的对象 } ... };
这个协议不仅适用于以上的标准赋值形式，也适用于所有赋值相关运算。例如：+=，*=，-=等。需要注意的是，这只是一个协议，并不是强制的。但是，最好还是这样做，因为这份协议被所有的内置类型和标准程序库提供的类型如string，vector，complex，tr1::shared_ptr或即将提供的类型所共同遵守的。
条款11：在operate=中处理“自我赋值”
自我赋值
“自我赋值”发生在对象被赋值给自己时：
class Widget{ ... }; Widget w; ... w = w; //赋值给自己
看着有些愚蠢，但它合法，不要以为大家绝对不这么做。以下为某些不明显“自我赋值”产生的情况：
（1）指针/引用指向同一个对象
a[i] = a[j]; //当i = j时 *px = *py // 当两个指针指向同一个东西时
（2）父类的指针和子类的指针指向同一个对象
class Base { ... }; class Derived: public Base { ... }; void doSomething(const Base& rb, Derived* pd); //rb和pd可能是同一个对象
自我赋值的后果
在我们打算自行管理资源时，自我赋值的情况可能会使我们掉进“在停止使用资源之前意外释放了它”的陷阱。假设建立一个class，来保存一个指针指向一块动态分配的位图（bitmap）：
class Bitmap{ ... }; class Widget{ ... private: Bitmap* pb; //指针，指向一个从heap分配而得的对象 };
下面是operate=的实现代码，
Widget& operate=(const Widget& rhs){ delete pb; //停止使用当前的bitmap pb = new Bitmap(rhs.pb); //使用rhs‘s bitmap的副本（不new的话，就指向一个bitmap了 return *this }
表面合理，但自我赋值出现时不安全：
Widget rhs； Widget w = rhs； //这是ok的 rhs = rhs; //第一步，将rhs.pb指向的对象删掉
解决方法
想要阻止这种做法，有以下方法：
（1）增加“证同测试”
Widget& operate=(const Widget& rhs){ if (this == &rhs) return *this; //如果是自我赋值，不要做任何事 delete pb; pb = new Bitmap(rhs.pb); return *this }
这样做行得通，具备了“自我赋值安全性”，但是还不具备“异常安全性”。如果”new Bitmap“导致了异常，Widget最终还是有一个指针指向一块被删除的Bitmap。这样的指针有害，你无法安全地删除它们，甚至无法安全地读取它们。
（2）在复制pb所指东西之前不要删除pb：
Widget& operate=(const Widget& rhs){ Bitmap* pOrig = pb; //pb和pOrig指向一个对象 pb = new Bitmap(rhs.pb); //pb指向rhs.pb的副本 delete pOrig ; //利用pOrig删去旧对象 return *this }
同时具备了“自我赋值安全性”和“异常安全性”。
（3）copy and swap技术
swap(Widget& rhs){ ... } //交换*this和rhs的数据
Widget& operate=(const Widget& rhs){
Widget temp(rhs); //为rhs的数据做一个复件
swap(temp); //将*this数据和上述复件的数据交换
return *this
}
如果创建指针的话，需要delete掉，但是创建对象的话，析构函数会delete掉指针。temp拷贝rhs的成功说明new Bitmap没有异常，然后swap。
更激进版：
swap(Widget& rhs){ ... } //交换*this和rhs的数据
Widget& operate=(Widget rhs){
swap(rhs); //将*this数据和上述复件的数据交换
return *this
}
传入值时，会自动生成复件。此时的rhs就是原rhs的拷贝。
条款12：复制对象时勿忘其每一个成分
copy构造函数和copy assignment操作符我们称之为copying函数，编译器会自动为我们的classes创建copying函数，将拷贝对象的所有成员变量都做一份拷贝。如果你声明自己的copying函数，可能会导致：
1. 如果你漏了一个成员变量没有复制，大多数编译器不会告诉你
2. 继承时，子类的copying函数只复制了子类的成员，而父类的成员变量会被默认的构造函数初始化
PriorityCustomer的copying函数没有复制Customer成员变量，PriorityCustomer的copy构造函数并没有指定实参传给其base class构造函数，因此PriorityCustomer对象的Customer成分会被不带实参的父类default构造函数初始化（上面的是伪代码，父类必须要有默认构造函数）。父类的default构造函数将对name和lastTransaction执行缺省的初始化动作。
base class 的成分往往是private， 所以你无法直接访问他们，你应该让derived class的copying函数调用相应的base class函数：
#include<iostream> using namespace std;
//--------父类-------------------------- class BasicCamera { public: BasicCamera() {}//父类必须要又默认构造函数，如果子类没有在拷贝构造的过程拷贝父类成员，那么子类会调用父类的默认构造函数，对父类的成员变量执行缺省的初始化。 BasicCamera(const BasicCamera& rhs) { name = rhs.name; } BasicCamera& operator=(const BasicCamera& rhs) {} void setname(string s) { name = s; } void show() { cout << "name is " << name << endl; } protected: private: std::string name; };
//---------------子类-------------- class HikCamera : public BasicCamera { public: HikCamera() {}; HikCamera(const HikCamera& rhs) :BasicCamera(rhs), price(rhs.price) { };//调用基类的copy构造函数 HikCamera& operator=(const HikCamera& rhs) { BasicCamera::operator =(rhs);//对基类成分进行赋值 price = rhs.price; return *this; }; void set(int x, string s) { BasicCamera::setname(s); price = x; } void show() { BasicCamera::show(); cout << "price is " << price << endl; } protected: private: int price; }; int main() { HikCamera cam; string s = "hik"; cam.set(100, s); HikCamera cam1(cam); cam1.show(); getchar(); }
运行结果
如果没有BasicCamera(rhs)，运行结果：
总结：
当你编写一个copying函数，请确保
1.复制所有的local成员变量，
2.调用所有的base class内的适当的copying函数。
当这两个copying函数有近似相同的实现本体，令一个copying函数调用另一个copying函数无法让你达到你想要的目标。
总结：
05：编译器可以暗自为class创建default构造函数、copy构造函数、copy assignment操作符以及析构函数。
08：析构函数绝对不要吐出异常。如果一个析构函数调用的函数可能抛出异常，析构函数应该捕捉任何异常，然后吞下它们（不传播）或结束程序。
08：如果客户需要对某个操作函数运行期间抛出的异常作出反应，那么class应该提供一个普通函数（而非析构函数中）执行该操作。
10：令赋值操作符返回一个reference to *this。
确保当对象自我赋值时operate=有良好行为，其中技术包括比较“来源对象”和目标对象“的地址、精心周到的语句顺序、以及cpoy and swap。
确定任何函数如果操作一个以上的对象，而其中多个对象是同一个对象时，其行为仍然正确。
12：Copying函数应该确保复制“对象内的所有成员变量”及”所有base class成分“。
12：不要尝试以某个copying函数实现另一个copying函数。应该将共同机能放进第三个函数中，并由两个copying函数共同调用。
参考：
1. 《Effective C++》P34-60
