在学习算法导论的过程中，我深深地震撼于自己笔下C++代码的丑陋。于是我决定捧起这本《Effective C++》。本来打算看完这本书，写一篇完整的笔记博文，但是刚刚看到一半，我已经跃跃欲试地想动手改善我的代码了。所以，我将写完的这部分笔记整理成单独的一篇博文。
1. 视C++为一个语言联盟。
- C++ 包括 C & OO C++ & Template C++ & STL
2. 使用 const，enum，inline 代替#define。
3. 尽可能使用 const
- const 修饰指针的不同含义
char* const p1 = "hello"; // 固定指针：不能使p2指向其他对象 const char* p2 = "hello"; // 固定数据：不能修改p2指向的对象
- const 修饰函数时的不同含义
class Text { public: const std::size_t length() const; // 返回文本的长度 // 第一个 const 表示 函数返回一个常量，不可作为左值使用 // 第二个 const 表示 函数不修改 Text 类中的数据成员（除了 static 和 mutable 修饰过的） private: char* data; };
当类的实例被声明为 const 时，只能调用被第二个 const 修饰过的函数。
4. 保证使用对象前进行初始化
- 内置数据类型不进行初始化，所有对象类型都有默认初始化函数。
- 在构造函数中对类成员赋值并不是真正意义的初始化，进入构造函数体时，对象成员都已经调用过默认初始化函数了。应当使用初始值列进行初始化。
class Person { public: Person(): name(), // 调用 string 类默认构造函数 sex_isMale(true) // 内置类型，必须初始化 {}; Person(const std::string& tname, const bool& isMale): name(tname), // 调用 string 类的复制构造函数 sex_isMale(isMale) {}; private: std::string name; bool sex_isMale; };
- 不同编译单元的 non-local static 对象（如全局对象）的初始化顺序不可控，将对象放在一个全局函数中，并将对象其声明为静态成员。第一次调用该函数时必定会初始化该对象。
5. 了解C++默默做的事
- 如果没有声明任何构造函数，则编译器自动为类实现默认构造函数。
- 如果你没有实现，编译器会自动为类实现复制构造函数，复制运算符（operator=）函数，析构函数。
- 如果类中包含引用类型的成员 或 const 成员，则编译器不会实现复制运算符函数。因为更改 引用 或 const 成员是不允许的。
6. 如果不想使用编译器自动生成函数，就该明确拒绝
- 将不想使用（如果你不声明，编译器就会自动生成）的函数 声明 为 private，并且不实现它（防止友元类调用）。
- 声明基类，并在基类中将不想使用的函数声明为 private，且不实现。继承基类的派生类，编译器不会自动生成相应函数。
class Uncopyble { protected: Uncopyble(){} ~Uncopyble(){} private: // 声明但不实现复制构造函数，其派生类无法调用基类的复制构造函数（由于private） // 因此编译器无法自动生成派生类的复制构造函数（默认的逻辑上，该函数应当调用基类的复制构造函数） Uncopyble(const Uncopyble&); // 复制操作符函数同理 Uncopyble& operator=(const Uncopyble&); };
7. 为多态基类声明virtual析构函数
- 如果基类的析构函数不是虚函数，那么通过基类指针引用的派生类对象，在其销毁时，只能销毁积累部分，而不能销毁派生类部分。
8. 不让异常逃离析构函数
- 析构函数往往并不由类的使用者亲自调用，因此在析构函数中抛出的异常难以捕捉。
- 如果在对象的销毁阶段确实可能抛出异常（比如，由于网络原因，关闭远程数据库失败），应该另外实现一个使用者亲自调用的销毁函数如close()，在该函数中抛出异常，以此给用户以机会处理异常。在析构函数中，检查用户是否调用了销毁函数：如果用户已经调用过，则不再调用该函数；如果用户未曾调用过，则调用该函数，在出现异常的情况下，并吞下异常或直接停止程序（用户没有立场抱怨，因为我们已经给了他机会）。
9. 不在构造函数或析构函数中调用virtual函数
- 派生类初始化时，先对基类部分初始化，然后才是派生部分。基类的构造函数运行时，派生类还不存在，此时调用虚函数并试图完成派生类中相应地逻辑：如果该虚函数有实现，就仅仅调用虚函数而不是派生类中的函数；如果没有定义虚函数，会出现连接错误。
- 析构函数同理。
10. 令 operator= 返回一个对 this 的引用
- 这样就可以使用连等式来赋值了。
11. 在 operator= 中处理自我赋值
- 在 operator= 中需要考虑参数就是自身的情况，也要注意语句顺序，以保证“异常安全性”。
12. 复制对象时不要忘了对象的每一个部分
- 如果自己实现复制构造函数和复制运算符函数（而不使用编译器自动生成的版本），一定要记得将所有的成员都复制过来，编译器不会因为这是个复制构造函数或operater=而帮你检查。
- 如果你在派生类中自己实现以上两种函数，一定要记得显式地调用基类的相应函数，编译器不会帮你调用。
class Person{ public: Person(){} Person(const std::string& tname):name(tname){} private: std::string name; }; class Citizen:public Person{ public: Citizen():Person(),married(false){} Citizen(Citizen& pcitizen): Person(pcitizen), // 显式调用基类的复制构造函数， // 注意传入的是pcitizen而不是pcitizen.name， // 因为调用的是基类的复制构造函数而不是构造函数， // 而且基类的private也不允许你这样做 married(pcitizen.married){} // 派生类部分的初始化 private: bool married; };
13. 以对象管理资源
- 所谓资源，往往是由 new 运算符产生的，由指针控制和管理的对象和数组。它们通常分配在堆（而不是栈）上，所以程序流程发生变化时，这些对象和数组不能自动销毁（而分配在栈上的对象是可以的），需要手动销毁。
- RAII：对象的取得时机就是最好的初始化时机，两种常用的RAII对象（智能指针）：std::auto_ptr<T>和std::tr1::shared_ptr<T>，前者的复制方案为“转让所有权”，后者的复制方案为“计数器”。
- 一个RAII对象示例
class FontHandle; class Font{ public: Font(FontHandle* ft): f(ft){} ~Font(){delete f;}
... private: FontHandle* f; };Font类的实例并不分配在堆上，但其指针成员 f 指向的对象 *f 分配在堆上。当流程变化时，Font 实例被正常销毁，其析构函数被调用，析构函数中将指针成员指向的对象销毁。这就保证了 *f 没有泄露。
14. 在资源管理器中小心 copying 行为
- 资源管理器的资源：即指针指向的对象，由资源管理器维护。当自己实现智能指针对象时，考虑一下四种 copying 行为。
- 禁止复制
- 引用计数（如shared_ptr，需用到类的静态成员）
- 深度复制
- 转让所有权（如auto_ptr）
- 考虑着四种 copying 行为的目的就是，避免在析构函数中多次试图销毁指针所指对象，或者完全不销毁。
15. 在资源管理器中提供对原始资源的访问
- 往往对 RAII 对象实现 operator-> 和 operator* 以实现对资源对象内部成员的访问。
- 实现显式转换函数，如 Font.get() 返回资源对象。
- 实现隐式转换函数，如 Font::operator FontHandle() 返回资源对象。此时，Font 对象 可 隐式转换为 FontHandle 对象，但也会带来部分风险。
class Font{ public: Font(FontHandle* ft): f(ft){} ~Font(){delete f;} operator FontHandle(){return *f;} FontHandle get(){return *f;} ... private: FontHandle* f; };
16. 成对使用 new 与 delete 时采取相同的形式
- 事实上，编译器中实现了两种指针，指向单个变量/对象 的 和指向变量/对象 数组的。使用 new 和 delete 时应当采取对应的形式。
std::string* s1 = new std::string("hello"); std::string* s2 = new std::string[100]; ... delete s1; delete [] s2;
17. 以独立语句将 newed 对象置入智能指针中
- 考虑这样做：
Font f1(new FontHandle);独立语句的含义是：不将该语句拆开，也不将其合并到其他语句中，这样可以确保资源不被泄露，如：
// 不将其拆开 FontHandle* fh1 = new FontHandle; ... // 发生异常怎么办？ Font f1(fh1); // 不将其合并 AnotherFunction(Font(new FontHandle), otherParameters /*发生异常怎么办？*/);
18. 让接口易于使用，难于误用
- 让接口易于使用，一般来说，就是尽量保持与内置类型（甚至STL）同样的行为。比如，你应当为 operator+ 函数返回 const 值，以免用户对计算结果进行赋值操作，内置类型不允许（对 int 型变量，语句 a+b=c 不能通过编译，所以你的类型也应该尽量保持同样的性质，除非你有更好的理由）；又比如，对象的主要组成部分如果是一个数组，那么数组的长度的成员名最好使用 size 而不是 length，因为 STL 也这么做了。
- 让借口难于误用，包括在类中限制成员的值（比如 Month 类型不可能表示 13 月），限制类型上的操作，在工厂函数中返回智能指针。
19. 设计 class 犹如 设计 type
20. 用 pass-by-reference-const 替换 pass-by-value
- 为函数传递参数时，使用使用 const 引用传递变量。在定义函数时：
class Person{...}; class Citizen:public Person{...}; bool validatePerson(Person psn){...} // 值传递，尽量不要这样做 bool validatePerson(const Person& psn){...} // const引用传递
- 使用const引用类型传递函数参数的好处在于：
- 免去不必要的构造开销：如果使用值传递，实参到形参的过程调用了类型的复制构造函数，而引用不会。
- 避免不必要的割裂对象：如果函数的参数类型是基类，而函数中又调用了派生类中的某种逻辑（即调用了基类中的虚函数），那么值传递的后果就是，形参仅仅是个基类对象，虚函数也仅仅就调用了虚函数自己（而不是派生类中的函数）。
- 对于C++内置类型和STL迭代器，使用值传递，以保持一致性。
21. 必须返回对象时，不要试图返回 reference
- 考虑一个有理数类：
class Rational{ public: Rational(int numerator=0, int denominator=1):n(numerator),d(denominator){} private: int n, d; };
-
任何有理数可用分数表示， n 和 d 分别为分子和分母，他们都是 int 型的。现在考虑为该类实现乘法，我们希望它能像内置类型一样工作。
Rational x = 2; Rational y(1,3); Rational z = x*y*y; // z等于2/9
- 我们可能会令函数返回引用类型（尤其是意识到20条中关于值传递的种种劣迹后）：
class Rational{ ... private: // 错误的代码 friend const &Rational operator* (const Rational& lhs, const Rational& rhs){ Rational result(lhs.n*rhs.n, lhs.d*lhs.d); return result; } ... };
result对象在 operator* 函数结束后就销毁了，但我们返回了它的引用！这个引用指向 result 对象原先的位置（编译器往往用指针实现引用），而且该位置在栈上！不仅无效，而且危险。
- 我们也可能用new运算符建立一个新的对象（以防止在函数结束后被销毁），并返回该对象的引用：
// 错误的代码 friend const &Rational operator* (const Rational& lhs, const Rational& rhs){ Rational* result = new Rational(lhs.n*rhs.n, lhs.d*lhs.d); return *result; }
这次，*result 对象不会因为函数结束而销毁了，它分配在堆上。但问题是，谁来负责销毁它？尤其是上文 z=x*y*y 中，由 y*y 计算而得到的临时变量，几乎不可能正常销毁。
- 正确的做法是：
// 正确的代码 friend const Rational operator* (const Rational& lhs, const Rational& rhs){ return Rational(lhs.n*rhs.n, lhs.d*lhs.d); }
虽然产生了构造消耗，但这是值得的。返回的对象 z 分配在栈上，也就是说会在适当的时候销毁，而原先函数中的临时变量也正常销毁了。
22. 将成员变量声明为 private
23. 以 non-member 和 non-friend 函数替换 non-member 函数
- 类的 public 方法越多，其封装性就越差，内部实现弹性就越小。设计类的时候应由其细心。对于一些便利函数（这些函数往往只调用函数的其他 public 方法），可考虑将其放置在类外。C++允许函数单独出现在类外，即使在C#等语言中，也可以使其出现在 工具 对象中。
- 将类外的函数与类声明在同一个命名空间中是不错的选择。
24. 如果函数的所有参数都需要类型转换，采用 non-member 函数
- 第21条中的代码已经体现出这一条的意思了。这一条大致就是希望 Rational 对象能像其他内置对象一样，直接参与运算。比如，希望这样：
Rational x(2,5); Rational y = x*2; Rational z = 2*x;
- 首先，Rational 构造函数没有使用 explicit 修饰，这意味着 x*2 可以正常计算，因为这会调用 x.operator*(Rational& a)，而整数 2 会隐式转换成 Rational 对象。（等等，在第21条中我们好像没有定义，x.operator*(Rational& a)函数？对，这是因为其中的代码已经遵循了本条的忠告，定义了 non-member 函数。）
- 如果在 Rational 中定义了x.operator*(Rational& a)，那么计算 z 时会遇到困难，因为系统会试图调用 Int32.operator*(Rational& a)，这根本没有定义。所以，我们在代码中并没有定义成员函数，而是定义了友元函数 Rational operator*(Rational& a, Rational& b)，正如在第21条的代码中显示的那样。
25. 考虑写一个不抛出异常的 swap 函数
- std::swap 函数采取复制构造的方法，效率比较低。
namespace std{ template <typename T> void swap(T& a, T& b){ T temp(a); a = b; b = a; } }
-
为自己的类实现 swap 方法并 特化 std::swap
class Person{ private: void* photo; }; namespace std{ template <> // 特化std::swap方法 void swap<Person>(Person& a, Person& b){ std::swap(a.photo, b.photo); } }
当自己的类较大时，可在类中定义swap方法，并在 std::swap<YourClass> 中调用该方法。
26. 尽量延后变量定义式的时间
- 仅当变量第一次具有“具有明显意义的初值”时，才定义变量，以避免不必要的构造开销。避免这样做：
std::string s; // 调用默认构造函数 ... // 如果发生异常呢，如果含有某个return语句呢？第一次调用构造函数的开销被浪费了 s = "Hello"; // 再一次调用构造函数，第一次调用构造函数的开销依然被浪费了
应当这样做：
std::string s("Hello"); // “hello”是具有明显意义的初值，只调用了一次构造函数
27. 尽量少做转型动作
- 四种转型动作
- const_cast：消除对象的常量性
- dynamic_cast：动态转换，开销较大。使用的场合往往是：想要在派生类上执行派生类的某个函数，但是手头上只有基类的指针指向该对象。
- reinterpret_cast：依赖于编译器的低级转型
- static_cast：强迫隐式转换，类似于C风格的转换，例如将int转换为double等
- 不要试图在派生类的成员函数中，通过dynamic_cast将(*this)转换为基类对象，并调用基类成员函数。
class Person{ public: void showMessage(){} }; class Citizen:public Person{ public: void showMessage(){ dynamic_cast<Person>(*this).showMessage(); // 错误，这样转型得到的并不是期望的“基类对象 } };
而应当这样做：
Person::showMessage(); // 这就对了
28. 避免返回 handles 指向对象内部部分
- handle 包括指针，引用，迭代器，用来获取某个对象，以前被翻译成句柄。
- 在函数的方法中返回对象内部成员的 handle 可能遭致这样的风险：返回的 handle 比对象本身更长寿，当对象销毁后，handle 所指向的区域就是不确定的。
- string 和 vector 类型的 operator[] 就返回了对象内部成员的 handle ，这只是例外。
29. 为“异常安全”而作的努力是值得的
- 函数异常安全类型：
- 基本承诺：如果异常抛出，程序内的所有元素仍然在有效状态下，没有任何元素受到损坏（如释放了指针指向资源却没有为其指定新的资源，该指针通向了不确定性）。
- 强烈保障：如果异常抛出，程序内的所有元素保持函数调用前的状态。
- 不throw异常：承诺绝不抛出异常。
- 一个函数异常安全的程度取决于所调用函数中异常安全程度最弱的。
- copy & swap 策略：为对象的数据制造一份副本，并对副本进行修改。如果发生异常，抛弃副本并返回；如果成功，则将对象数据与副本数据做 swap 操作，swap 操作承诺绝不抛出异常。