《More Effective C++》笔记

基础议题

pointers（指针）、references（引用）、casts（类型转换）、arrays（数组）、constructors（构造函数）。

1：仔细区别 pointers和 references

没有所谓的 null reference。一个 reference 必须总代表某个对象。所以如果你有一个变量，其目的是用来指向（代表）另一个对象，但是也有可能它不指向（代表）任何对象，那么你应该使用 pointer，因为你可以将 pointer设为 null。
当你需要考虑“不指向任何对象”的可能性时，或是考虑“在不同时间指向不同对象”的能力时，你就应该采用 pointer。
当你知道你需要指向某个东西，而且绝不会改变指向其他东西，或是当你实现一个操作符而其语法需求无法由pointers 达成，你就应该选择 references。任何其他时候，请采用pointers。

2：最好使用 C++转型操作符

C++导入 4个新的转型操作符（castoperators）：static_cast，const_cast，dynamic_cast 和reinterpret_cast。

static_cast 基本上拥有与 C 旧式转型相同的威力与意义，以及相同的限制。
例如，你不能够利用 static_cast 将一个 struct 转型为 int，或将一个 double转型为 pointer；这些都是 C 旧式转型动作原本就不可以完成的任务。
const_cast 用来改变表达式中的常量性（constness）或变易性（volatileness）。
使用 const_cast，便是对人类（以及编译器）强调，通过这个转型操作符，你唯一打算改变的是某物的常量性或变易性。这项意愿将由编译器贯彻执行。如果你将 const_cast 应用于上述以外的用途，那么转型动作会被拒绝。
dynamic_cast，用来执行继承体系中“安全的向下转型或跨系转型动作”。
也就是说你可以利用dynamic_cast，将“指向 base class objects的 pointers或references”转型为“指向 derived（或 sibling base）class objects的pointers 或 references”，并得知转型是否成功。
如果转型失败，会以一个 null指针（当转型对象是指针）或一个 exception（当转型对象是 reference）表现出来。
dynamic_cast 只能用来协助你巡航于继承体系之中。它无法应用在缺乏虚函数（请看条款 24）的类型身上，也不能改变类型的常量性（constness）。
reinterpret_cast 的最常用用途是转换“函数指针”类型。

class Widget {
public:
    // 必须要添加，dynamic_cast需要baseClass是多态的。
    // 否则error: 'Widget' is not polymorphic
    virtual ~Widget() = default;
};

class SpecialWidget : public Widget {
public:
    ~SpecialWidget() override = default;
};

void update(SpecialWidget *psw) {};
void update2(SpecialWidget &psw) {};

void testMore02() {
    SpecialWidget sw;
    const SpecialWidget &csw = sw;

    // update(&csw); // 错误，函数参数非const
    update(const_cast<SpecialWidget *>(&csw)); // 使用const_cast改变表达式中的常量性
    update((SpecialWidget *) &csw); // 旧式语法直接转换
    update2(const_cast<SpecialWidget &>(csw));
    update2((SpecialWidget &) csw); // 旧式语法直接转换

    Widget *pw = new SpecialWidget;
    // update(pw); // 错误，函数需要SpecialWidget
    update(dynamic_cast<SpecialWidget *>(pw));
    update2(dynamic_cast<SpecialWidget &>(*pw));
}

3：绝对不要以多态（polymorphically）方式处理数组

C++语言规范中说，通过 base class 指针删除一个由derived classes objects构成的数组，其结果未定义。我们知道所谓“未定义”的意思就是：执行之后会产生苦恼。

多态（polymorphism）和指针算术不能混用。数组对象几乎总是会涉及指针的算术运算，所以数组和多态不要混用。

4：非必要不提供 default constructor

所谓 default constructor（也就是说不给任何自变量就可调用者）是C++一种“无中生有”的方式。Constructors 用来将对象初始化，所以default constructors 的意思是在没有任何外来信息的情况将对象初始化。
为一个不需要 defaultconstructor 的 class 画蛇添足地加上一个 default constructor”而获得提升。同事添加无意义的 default constructors，也会影响 classes 的效率。

但无default constructor有以下缺点，需要在开发过程中注意：

缺乏 default constructor，其运行可能在 3种情况下出现问题。第一个情况是在产生数组的时候。一般而言没有任何方法可以为数组中的对象指定 constructor 自变量，所以几乎不可能产生一个由 EquipmentPiece objects 构成的数组：
Classes 如果缺乏 default constructors，带来的第二个缺点是：它们将不适用于许多 template-based container classes。

操作符（Operators）操作符

5：对定制的“类型转换函数”保持警觉

6：区别 increment/decrement 操作符的前置（prefix）和后置（postfix）形式

7：千万不要重载&&，||和，操作符

8：了解各种不同意义的 new和 delete

new operator、delete operator
这个操作符是由语言内建的，就像sizeof 那样，不能被改变意义，总是做相同的事情。它的动作分为两方面。
第一，它分配足够的内存，用来放置某类型的对象。以上例而言，它分配足够放置一个string 对象的内存。
第二，它调用一个 constructor，为刚才分配的内存中的那个对象设定初值。newoperator总是做这两件事，无论如何你不能够改变其行为。
函数
void* operator new(size_t size)
void operator delete(void* memoryToBeDeallocated)

异常（Exceptions）异常

9：利用 destructors避免泄漏资源

在对象析构函数中释放资源；
使用智能指针。

10：在 constructors内阻止资源泄漏（resource leak）

结论是：如果你以 auto_ptr 对象来取代 pointer class members，你便对你的constructors 做了强化工事，免除了“exceptions 出现时发生资源泄漏”的危机，不再需要在 destructors 内亲自动手释放资源，并允许 const member pointers 得以和non-const member pointers有着一样优雅的处理方式。

11：禁止异常（exceptions）流出 destructors之外

在析构函数中使用try-cach，如果有异常发生的话。这么做有如下好处：

它可以避免 terminate函数在 exception传播过程的栈展开（stack-unwinding）机制中被调用；
它可以协助确保destructors 完成其应该完成的所有事情

12：了解“抛出一个 exception”与“传递一个参数”或“调用一个虚函数”之间的差异

13：以 by reference方式捕捉 exceptions

它不像 catch-by-pointer，不会发生对象删除问题，因此也就不难捕捉标准的 exception。
它和 catch-by-value也不同，所以没有切割（slicing）问题，而且exception objects 只会被复制一次。

void fun() {
    try {
    } catch(exception& ex) {
        // 使用引用捕获异常
    }
}

14：明智运用 exception specifications

15：了解异常处理（exception handling）的成本

如果使用 try 语句块，代码大约整体膨胀 5%～10%，执行速度亦大约下降这个数。这是在假设没有任何 exceptions被抛出的情况下。
和正常的函数返回动作比较，由于抛出exception 而导致的函数返回，其速度可能比正常情况下慢 3个数量级。

效率（Efficiency）效率

16：谨记 80-20 法则

软件的整体性能几乎总是由其构成要素（代码）的一小部分决定。
一个程序 80%的资源用于 20%的代码身上。是的，80%的执行时间花在大约 20%的代码身上，80%的内存被大约 20%的代码使用，80%的磁盘访问动作由 20%的代码执行，80%的维护力气花在 20%的代码上面。
假设你的程序太慢，你需要一个分析器告诉你程序的不同区段各花费多少时间，于是你便可以专注在特别耗时的地方加以改善，这不但可以巨幅提升局部效率，对整体效率也会有极大帮助。

17：考虑使用 lazy evaluation（缓式评估）

18：分期摊还预期的计算成本

19：了解临时对象的来源

20：协助完成“返回值优化（RVO）”

此特殊的优化行为——利用函数的 return 点消除一个局部临时对象（并可能用函数调用端的某对象取代）——不但广为人知而且很普遍地被实现出来。它甚至有个专属名称：return value optimization。

21：利用重载技术（overload）避免隐式类型转换（implicit type conversions）

22：考虑以操作符复合形式（op=）取代其独身形式（op）

23：考虑使用其他程序库

24：了解 virtual functions、multiple inheritance、virtual base classes、runtime type identification的成本

virtualtables和 virtual table pointers——此二者常被简写为 vtbls 和vptrs。
vtbl 通常是一个由“函数指针”架构而成的数组。
你必须为每个拥有虚函数的 class耗费一个vtbl 空间，其大小视虚函数的个数（包括继承而来的）而定。
每个class 应该只有一个 vtbl，所以 vtbls 的总空间通常并不是很大，但如果你有大量这类 classes，或是你在每一个 class 中拥有大量虚函数，你可能会发现，vtbls 占用不少内存。
凡声明有虚函数的 class，其对象都含有一个隐藏的 data member，用来指向该class 的 vtbl。这个隐藏的 data member——所谓的 vptr——被编译器加入对象内某个唯编译器才知道的位置。
运行时期类型辨识（runtime typeidentification，RTTI）的成本。
RTTI 让我们得以在运行时期获得 objects 和 classes 的相关信息，所以一定得有某些地方用来存放那些信息才行——是的，它们被存放在类型为 type_info 的对象内。
RTTI 的设计理念是：根据 class 的 vtbl 来实现。