Effective C++总结

条款01：视C++为一个语言联邦（View C++ as a federation of languages.）

C++主要的四个次语言：

（1）C。说到底C++仍是以C为基础；（2）Object-Oriented C++。这部分也就是C with Classes所诉求的：类、封装、继承、多态、虚函数；（3）Template C++。这是C++的泛型编程（generic programming）部分；（4）STL。STL是个template程序库，是非常特殊的一个。它对容器、迭代器、算法以及函数对象的规约有极佳的紧密配合与协调。

请记住：

C++高校编程守则视状况而变化，取决于你使用C++的哪一部分。

条款02：尽量以const，enum，inline替换#define（Prefer consts,enums, and inline to #defines.）

用宏（#define）经常会导致使用的变量名称可能并未进入记号表（symbol table），会对调试带来许多问题，用const常量替换宏可以解决这个问题。

class专属常量，为了确保常量至多只有一份，必须让它成为一个static成员。可以在类中的声明式给予初值，如果之后不取它们的地址，可以只声明它们而无需提供定义式。但如果需要取某个class专属常量的地址，或编译器却坚持要看到一个定义式，就必须另外提供定义式。注意定义式放在实现文件而非头文件。

当class编译期间需要一个class常量值，这时候万一编译器（错误地）不允许”static整数型calss常量“完成”in class初值设定“，可改用所谓的”the enum hack“补偿做法。理论基础是：”一个属于枚举类型（enumerated type）的数值可权充ints被使用“。类似下面：

class GamePlayer {
private:
	enum {NumTurns = 5}; // "the enum hack"令NumTurns成为5的一个记号名称
	int scores[NumTurns]; // 这就没问题了
}

1、enum hack的行为某方面说比较像#define而不像const。

2、认识enum hack的第二个理由纯碎是为了实用主义。许多代码使用了它，事实上”enum hack“是template metaprogramming（模版元编程）的基础技术。

预处理器另一个常见的#define误用情况是以它实现宏（macros），宏看起来像函数，但不会招致函数调用带来的额外开销。下面例子

#define CALL_WITH_MAX(a,b) f((a) < (b) ? (a) : (b))

int a = 5, b = 0;
CALL_WITH_MAX(++a, b); // a被累加两次
CALL_WITH_MAX(++a, b + 10); // a被累加一次

在这里，调用f之前，a的递增次数竟然取决于”它被拿来和谁比较“！

这里用template inline函数就可以获得宏带来的效率以及一般函数的所有可预料行为和类型安全性。

template<typename T>
inline void callWithMax(const T& a, const T& b)
{
	f(a > b ? a : b);
}

此外由于callWithMax是个真正的函数，它遵守作用域（scope）和访问规则。一般而言宏无法完成此事。

请记住：

对于单纯常量，最好以const 对象或enums替换#define。

对于形似函数的宏（macros），最好改用inline函数替换#define。

条款03：尽可能使用const（Use const whenever possible）

请记住：

将某些东西声明为const可帮助编译器侦测出错误用法。const可被施加于任何作用域内的对象、函数参数、函数返回类型、成员函数本体。

编译器强制实施bitwise constness，但你编写程序时应该使用“概念上的常量性”（conceptual constness）

当const 和non-const成员函数有着实质等价的实现时，令non-const版本调用const版本可避免代码重复。

条款04：确定对象被使用前已先被初始化（Make sure that objects are initialized before they're used）

请记住：

为内置对象进行手工初始化，因为C++不保证初始化它们。

构造函数最好使用成员初值列（member initialization list），而不要在构造函数本体内使用赋值操作（assignment）。初值列列出的成员变量，其排列次序应该和它们在class中的声明次序相同。

为免除“跨编译单元之初始化次序”问题，请以local static对象（函数内的static对象成为local static对象，因为它们对函数而言是local）替换non-const static对象。

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

如果自己没有声明，编译器就会为空类声明（编译器版本）一个copy构造函数，一个copy assignment操作符和一个析构函数。如果没有声明任何构造函数，编译器也会声明一个default构造函数。所有这些函数都是public且inline。

惟有当这些函数被需要（调用），它们才会被编译器创建出来。

编译器产生的析构函数是个non-virtual。

至于copy构造函数和copy assignment操作符，编译器创建的版本只是单纯地将来源对象的每一个non-static成员变量拷贝到目标对象。

copy构造函数对于成员是类的情况下，这个成员变量的初始化方式是调用这个类的copy构造函数并以传入的对象为实参。如果是内置类型，会以”拷贝来源数据的每一个bits“来完成工作。

copy assignment操作符，一般而言只有当生出的代码合法且有适当机会证明它有意义；如果一个模版类中含有一个reference to string，一个const T（模版类），初始化两个对象p和s，如果有p = s这样的操作，编译器的响应是拒绝编译那一行的赋值动作。如果你打算在一个”内含reference成员“的class内支持赋值操作（assignment），你必须自己定义copy assignment操作符。面对”内含const成员“的classes，编译器的反应也一样。最后还有一种情况：如果某个基类将cooy
assignment操作符声明为private，编译器将拒绝为其派生类生成一个copy assignment操作符。毕竟编译器为其派生类所生的copy assignment操作符想象中可以处理基类成分。

请记住：

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

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

请记住：

为驳回编译器自动（暗自）提供的机能，可将相应的成员函数（例如copy构造函数和copy assignment操作符）声明为private并且不予实现。使用像Uncopyable这样的base class也是一种做法。（为了阻止类对象被拷贝，只需要继承Uncopyable即可）

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

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

一个函数返回值是一个基类指针，当返回的是派生类指针时，delete这个指针的时候就会造成“局部销毁”对象，形成资源泄漏。给基类一个virtual析构函数就可以解决这个问题。

由于virtual函数的实现细节会导致类的大小增加，所以对于类中不含virtual函数的基类，令其析构函数为virtual往往是个馊主意。

许多人的心得是：只有当class内含有至少一个virtual函数才为它声明virtual析构函数。

有时候希望某个类成为抽象类，但是又没有纯虚函数，此时可以把析构函数声明为纯虚析构函数。这里有个窍门：你必须为这个pure virtual析构函数提供一份定义（因为编译器会在深层的派生类的析构函数会中创建对基类的虚构函数的调用）。

请记住：

polymorphic（带多态性质的）基类应该声明一个virtual析构函数。如果class带有任何virtual函数，它就应该有一个virtual析构函数。

Classes的设计目的如果不是作为base classes使用（例如标准string 和STL容器），或不是为了具备多态性（polymorphically），就不该声明virtual析构函数。

条款08：别让异常逃离析构函数（Prevent exceptions form leaving destructors.）

请记住：

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

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

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

请记住：

在构造和析构期间不要调用virtual函数，因为这类调用从不下降至derived class（比起当前执行构造函数和析构函数的那层）。一种解决方法是：将基类中想调用的虚函数改为non-virutal，然后要求派生类构造函数传递必要信息给基类构造函数，然后那个构造函数便可安全地调用non-virtual函数。

条款10：令operator=返回一个reference to *this（Have assignment operators returne a reference to *this.）

请记住：

令赋值（assignment）操作符（包括赋值相关运算，比如+=）返回一个reference to *this。

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

请记住：

确保当对象自我赋值时operator= 有良好的行为。其中技术包括比较“来源对象”和“目标对象”的地址、精心周到的语句顺序、以及copy-and-swap。

确定任何函数如果操作一个以上的对象，而其中多个对象是同一个对象时，其行为仍然正确。

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

请记住：

Copying函数应该确保复制“对象内的所有成员变量”及“所有base class成分“。（1、复制所有local成员变量；2、调用所有base classes内的适当copying函数）

不要尝试以某个copying函数实现另一个copy函数。应该将共同机能放进第三个函数中（这样的函数往往是private而且常被命名为init），并由两个copying函数共同调用。

条款13：以对象管理资源（Use objects to manage resources）

请记住：

为防止资源泄漏，请使用RAII（Resource Acquisition Is Initialization，资源取得时机便是初始化时机）对象，它们在构造函数中获得资源并在析构函数中释放资源。

两个常被使用的RAII classes分别是 是shared_ptr 和 unique_ptr。前者通常是较佳选择，因为其copy行为比较直观。若选择后者，复制动作会使它（被复制物）只想null。（详情请看：C++11特性 - Smart Pointers 智能指针）

条款14：在资源管理类中小心copying行为（Think carefully about aopying behavior in resource-managing classes.）

请记住：

复制RAII对象必须一并复制它所管理的资源，所以资源的copying行为决定RAII对象的copying行为。

普通而常见的RAII class copying行为是：抑制copying、施行引用计数法（reference counting）。不过其他行为也都可能被实现。

条款15：在资源管理类中提供对原始资源的访问（Provide access to raw resources in resource-managing classes.）

请记住：

APIs往往要求访问原始资源（raw resources），所以每一个RAII class应该提供一个“取得其所管理之资源”的办法。

对原始资源的访问可能经由显示转换或隐式转换。一般而言显示转换比较安全。（比如 shared_ptr 和 unique_ptr 提供了get方法取得原始指针）

条款16：成对使用new和delete时要采取相同形式（Use the same form in corresponding uses of new and delete.）

请记住：

最好尽量不要对数组形式做typedef动作。

如果你在new表达式中使用 [ ] ，必须在相应的delete表达式中也使用 [ ] 。如果你在new表达式中不使用 [ ] ，一定不要在相应的delete表达式使用 [ ] 。

条款17：以独立语句将newed对象置入智能指针（Store newed objects in smart pointers in standalone statements.）

请记住：

以独立语句将newed对象存储于（置入）只能指针内。如果不这样做，一旦异常被抛出，有可能导致难以察觉的资源泄漏。

条款18：让接口容易被正确使用，不易被误用（Make interfaces easy to use correctly and hard to use incorrectly）

请记住：

好的接口很容易被正确使用，不容易被误用。你应该在你的所有接口中努力达成这些性质。

”促进正确使用“的办法包括借口的一致性，以及与内置类型的行为兼容。

”阻止误用“的办法包括建立新类型、限制类型上的操作，束缚对象值，以及消除客户的资源管理责任。

shared_ptr支持定制型删除器（custom deleter）。这可防范DLL问题，可被用来自动解除互斥锁（mutexes）等等。

条款20：宁以pass-by-reference-to-const替换pass-by-value（Prefer pass-by-reference-to-const to pass-by-value）

请记住：

尽量以pass-by-reference-to-const替换pass-by-value。前者通常比较高效，并可避免切割问题（slicing problem）。

以上规则并不适用于内置类型，以及STL的迭代器和函数对象。对它们而言，pass-by-balue往往比较适当。

条款21：必须返回对象时，别妄想返回其reference

请记住：

绝不要返回pointer或reference指向一个local stack对象，或返回reference指向一个heap-allocated对象，或返回pointer或reference指向一个local static对象而有可能同时需要多个这样的对象。

条款22：将成员变量声明为private

请记住：

切记将成员变量声明为private。这可赋予客户访问数据的一致性、可细微划分访问控制、允诺约束条件获得保证，并提供class作者以充分的实现弹性。

protected并不比public更具封装性。

条款23：宁以non-member、non-friend替换member函数（Prefer non-memeber non-friend functions to member functions.）

请记住：

宁可拿non-member non-friend函数替换member函数。这样做可以增加封装性、包裹弹性（packaging flexibility）和机能扩充性。

条款24：若所有参数皆需类型转换，请为此采用non-member函数（Declare non-member functions when type conversions should apply to all parameters.）

请记住：

如果你需要为某个函数的所有参数（包括被this指针所指的那个隐喻参数）进行类型转换，那么这个函数必须是个non-member。（注意有时候friend有其正当性，但这个事实依然存在：不能够只因函数不该成为member，就自动让它成为friend。

条款25：考虑写出一个不抛异常的swap函数（Consider support for a non-throwing swap.）

请记住：

当std::swap对你的类型效率不高时，提供一个swap成员函数，并确定这个函数不抛出异常。

如果你提供一个member swap，也该提供一个non-member swap用来调用前者。对于classes（而非template），也请特化std::swap。

调用swap时应针对std::swap使用using声明式，然后调用swap并且不带任何”命名空间资格修饰“。

为”用户定义类型“进行std template 全特化是好的，但千万不要尝试在std内加入某些对std而言是全新的东西。

条款26：尽可能延后变量定义式的出现时间（Postpone variable definitions as long as possible.）

对于只在循环内使用的变量，对于定义于循环外并在每次循环迭代时赋值给它比较好，还是该把它定义与循环内？杰伦：除非（1）你知道赋值成本比”构造+析构“成本低，（2）你正在处理代码中效率高度敏感的（performance-sensitive）的部分，否则你应该使用做法：定义于循环内。

请记住：

尽可能延后变量定义式的出现。这样做可增加程序的清晰度并改善程序效率。

条款27：尽量少做转型动作（Minimize casting.）

C++类型转换相关请看：C++类型转化。

请记住：

如果可以，尽量避免转型，特别是在注重效率的代码中避免dynamic_casts。如果有个设计需要转型动作，试着发展无需转型的替代设计。

如果转型是必要的，试着将它隐藏于某个函数背后。客户随后可以调用该函数，而不需要将转型放进他们自己的代码中。

宁可使用C++-style（新式）转型，不要使用旧式转型。前者很容易辨识出来，而且也比较有着分门别类的职掌。

条款28：避免返回handles指向对象内部成分（Avoid returning  "handles"  to object internals.）

请记住：

避免返回handles（包括reference、指针、迭代器）指向对象内部。遵守这个条款可增加封装性，帮助const成员函数的行为像个const，并将发生”虚吊号码牌“（dangling handles）的可能性将至最低。

条款29：为“异常安全”而努力是值得的（Strive for exception-safe code.）

当你撰写新码或修改旧码时，请仔细想想如何让它具备异常安全性。（1）首先是“以对象管理资源”（条款13），那可组织资源泄漏。（2）然后是挑选三个“异常安全保证”中的某一个实施于你所写的每一个函数身上。你应该挑选“现实可操作”条件下的最强烈等级，只有当你的函数调用了传统代码，才别无选择地将它设为“无任何保证”。（3）将你的决定写成文档，这一来是为了你的函数用户着想，二来是为了将来的维护者着想。

请记住：

异常安全函数（Exception-safe function）即使发生异常也不会泄漏资源或允许任何资源结构败坏。这样的函数区分为三种可能的保证：基本型、强烈型、不抛异常型。

“强烈保证”往往能够以copy-and-swap实现出来，但“强烈保证“并非对所有函数都可实现或具备现实意义。

函数提供的”异常安全保证“通常最高只等于其所调用支各个函数的”异常安全保证“中的最弱者。

条款30：透彻了解inlining的里里外外（Understand the ins and outs of inlining.）

如果inline函数的本体很小，编译器针对”函数本体“所产出的码可能比针对”函数调用“所含产出的码更小。

记住，inline只是对编译器的一个申请，不是强制命令。

大部分编译器拒绝将太过复杂（例如带有循环或递归）的函数inlining，而所有对virtual函数的调用（除非是最平淡无奇的）也都会使inlining落空。

编译器通常不对”通过函数指针而进行的调用“实施inlining。

80-20经验法则：平均而言一个程序往往将80%的执行之间花费在20%的代码上头。这个一个重要的法则，因为它提醒你，作为一个软件开发者，你的目标是找出这可以有效增加程序整体效率的20%代码，然后将它inline或竭尽所能地将它瘦身。但除非你选对目标，否则一切都是虚功。

请记住：

将大多数inlining限制在小型、被频繁调用的函数身上。这可使日后的调试过程和二进制升级（binary upgradability）更容易，也可使潜在的代码膨胀问题最小化，使程序的速度提升机会最大化。

不要只因为function templates出现在头文件，就将它们声明为inline。