代码笔记 - Effective cpp

最新推荐文章于 2024-09-14 11:23:35 发布

luoshi006

最新推荐文章于 2024-09-14 11:23:35 发布

阅读量413

点赞数 1

分类专栏：随笔文章标签： cpp

本文链接：https://blog.csdn.net/luoshi006/article/details/89436272

版权

随笔专栏收录该内容

7 篇文章 0 订阅

订阅专栏

Effective cpp 读书笔记

导读

// P5
class Widget {
public:
    Widget();                       // default 构造函数
    Widget(const Widget& rhs);      // copy 构造函数
    Widget& operator=(const Widget& rhs);   // copy assignment 操作符
};

Widget w3 = w2;                     // 调用 copy 构造函数

lhs     ->      left hand side
rhs     ->      right hand side

1. 让自己习惯 c++

item 01: view cpp as a federation fo languages.

C part of C++
- 面向过程 procedural
- C with Classes
Object-Oriented C++
- 类、封装、继承、多态、虚函数
Template C++
- 泛型编程（generic programming）
- 模板元编程（template metaprogramming, TMP）

item 02: prefer consts, enums, and inlines to #define.

#define 可能导致变量不会进入符号表（symbol table）；
enum hack 代替 #define ；
template inline 代替 #define 函数宏；

item 03: use const whenever possible.

const char *p;      // const data;
char const *p;      // const data;
char* const p;      // const pointer;

两个成员函数如果只是常量属性（constness）不同，可以被重载。
mutable 释放掉 non-static 成员变量的 bitwise constness 约束。
当 const 和 non-const 成员函数有着实质等价的实现时，令 non-const 版本调用 const 版本可避免代码重复。

item 04: make sure that objects are initialized before they're used.

永远在使用对象之前先将它初始化；
确保构造函数将对象的每一个成员初始化；
不要混淆赋值（assignment）和初始化（initialization）；
函数内的 static 对象称为 local static 对象，其他 static 对象称为 non-local static 对象；

2. 构造/析构/赋值运算

item 05: know what functions C++ silently writes and calls.

声明任意构造函数，编译器将不再为其创建 default 构造函数；
如果没有声明 copy / copy assignment 构造函数，编译器将会在他们被调用的情况创建；

item 06: explicitly disallow the use of compiler-generated functions you do not want.

为防止编译器隐式提供的接口，可将相应的成员函数声明为 private 并不予实现；

class Uncopyable {
protected:
    Uncopyable() {}                 // 允许子类对象构造和析构
    ~Uncopyable() {}
private:
    Uncopyable( const Uncopyable& );        // 阻止 copy 操作
    Uncopyable& operator=( const Uncopyable& );
};

class Home : private Uncopyable {};

item 07: declare destructors virtual in polymorphic base classes.

polymorphic (多态) base classes 应该声明一个 virtual 析构函数。如果 class 带有任何 virtual 函数，它就应该拥有一个 virtual 析构函数。
Classes 的设计目的如果不是作为 base classes 使用，或不是为了具备多态性（polymorphically），就不该声明 virtual 析构函数。

item 08: prevent exceptions from leaving destructors.

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

item 09: never call virtual functions during construction or destruction.

在基类构造期间，virtual 函数不是 virtual 函数。
在构造和析构期间不要调用 virtual 函数，因为这类调用从不下降至 derived classes。

item 10: have assignment operators return a reference to *this.

令赋值（assignment）操作符返回一个 reference to *this。以便兼容连等形式调用。

item 11: handle assignment to self in operator=.

确保当对象自我赋值时 operator= 有良好行为。其中技术包括比较“来源对象”和“目标对象”的地址、精心周到的语句顺序、以及 copy-and-swap。
确定任何函数如果操作一个以上的对象，而其中多个对象是同一个对象时，其行为仍然正确。

item 12: copy all parts of an object.

copying 函数应该确保复制“对象内的所有成员变量”及“所有 base class 成分”。
不要尝试以某个 copying 函数实现另一个 copying 函数。应该将共同机能放进第三个函数中，并由两个 copying 函数共同调用。

3. 资源管理

item 13: use objects to manage resources.

获取资源后立刻放进管理对象内（自动指针、智能指针）；
管理对象运用析构函数确保资源被释放；
为防止资源泄露，请使用 RAII（Resource Acquisition Is Initialization）对象，它们在构造函数中获得资源并在析构函数中释放资源；
两个常被使用的 RAII classes 分别是 tr1::shared_ptr 和 auto_ptr。前者通常是较佳选择，因为其 copy 行为比较直观。若选择 auto_ptr，赋值动作会使它（被复制对象）指向 NULL。

item 14: think carefully about copying behavior in resource-managing classes.（没看懂）

复制 RAII 对象必须一并复制它所管理的资源，所以资源的 copying 行为决定 RAII 对象的 copying 行为。
普遍而常见的 RAII class copying 行为是：抑制 copying、施行引用计数法。不过其他行为也可能被实现。

item 15: provide access to raw resources in resource-managing classes.

APIs 往往要求访问原始资源（raw resources），所以每一个 RAII class 应该提供一个“取得其所管理之资源”的办法；
对原始资源的访问可能经由显示转换或隐式转换。一般而言显式转换比较安全，但是隐式转换对客户比价方便。

item 16: use the same form in corresponding uses of new and delete.

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

item 17: store newed objects in smart pointers in standalone statements.

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

4. 设计与声明

item 18: make interfaces easy to use correctly and hard to use incorrectly.

好的接口很容易被正确使用，不容易被误用。你应该在你的所有接口中努力达成这些性质。
“促进正确使用”的办法包括接口的一致性，以及与内置类型的行为兼容。
“阻止误用”的办法包括建立新类型、限制类型上的操作，束缚对象值，以及消除客户的资源管理责任。
tr1::shared_ptr 支持定制型删除器（custom deleter）。这可防范 dll 问题，可被用来自动解除互斥锁（mutexes; 见 item 14）等等。
好的接口可以防止无效的代码通过编译。

item 19: treat class design as type design.

class 的设计就是 type 的设计。在定义一个新 type 之前，请确定你已经考虑过本条款覆盖的所有讨论主题。

item 20: prefer pass-by-reference-to-const to pass-by-value.

尽量以 pass-by-reference-to-const 替换 pass-by-value。前者通常比较高效，并可避免切割问题（slicing problem）。
以上规则并不适用于内置类型，以及 STL 的迭代器和函数对象。对它们而言，pass-by-value 往往比较适当。

item 21: don't try to return a reference when you must return an object.

绝不要返回 pointer 或 reference 指向一个 local stack 对象，或返回 reference 指向一个 heap-allocated 对象，或返回 pointer 或 reference 指向一个 local static 对象而有可能同时需要多个这样的对象。item 4 已经为 “在单线程环境中合理返回 reference 指向一个 local static 对象”提供了一份设计实例。

item 22: declare data members private.

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

item 23: prefer non-member non-friend functions to member functions.

namespace 和 classes 不同，前者可以跨越多个源码文件而后者不能。（namespace 的用法）
尽量用 non-member non-friend 函数替换 member 函数。这样做可以增加封装性、包裹弹性（packaging flexibility）和机能扩充性。

item 24: declare non-member functions when type conversions should apply to all parameters.

如果你需要为某个函数的所有参数（包括被 this 指针所指的那个隐喻函数）进行类型转换，那么这个函数必须是个 non-member。
member 函数对应 non-member 函数，而不是 friend 函数。不能够只因函数不该成为 member，就自动让它成为 friend。

item 25: consider support for a non-throwing swap.

当 std::swap 对你的类型效率不高时，提供一个 swap 成员函数，并确定这个函数不抛出异常。
如果你提供一个 member swap，也该提供一个 non-member swap 用来调用前者。对于 classes（而非 templates），也请特化 std::swap。
调用 swap 时应针对 std::swap 使用 using 声明式，然后调用 swap 并且不带任何“命名空间资格修饰”。
为“用户定义类型”进行 std templates 全特化是好的，但千万不要尝试在 std 内加入某些对 std 而言全新的东西。

5. 实现

item 26: postpone variable definitions as long as possible.

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

item 27: minimize casting.

const_cast<T>(...), dynamic_cast<T>(...), reinterpret_cast<T>(...), static_cast<T>(...)
单一对象可能拥有一个以上的地址，父类指针和子类指针指向的地址有一个 offset。
如果可以，尽量避免转型，特别是在注重效率的代码中避免 dynamic_casts。如果有个设计需要转型动作，试着发展无需转型的替代设计。
如果转型是必要的，试着将它隐藏于某个函数背后。客户随后可以调用该函数，而不需将转型放进他们自己的代码内。
宁可使用 C++ style 转型，不要使用旧式转型。前者很容易辨识出来，而且也比较有着分门别类的职掌。

item 28: avoid returning "handles" to object internals.

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

item 29: strive for exception-safe code.

异常安全要求：不泄露任何资源；不允许数据败坏；
异常安全函数提供以下三个保证之一：
- 基本承诺；如果异常被抛出，程序内的任何事物仍然保持在有效状态下。没有任何对象或数据结构会因此而败坏。
- 强烈保证；如果异常被抛出，程序状态不改变。函数成功，则成功；函数失败，则恢复到之前的状态。
- 不抛掷（nothrow）保证；承诺不抛出异常。
不要为了表示某件事情发生而改变对象状态，除非那件事情真的发生了。（count++）
异常安全函数（exception-safe functions）即使发生异常也不会泄露资源或允许任何数据结构败坏。这样的函数区分为三种可能的保证：基本型、强烈型、不抛异常型。
强烈保证通常能够以 copy-and-swap 实现出来，但强烈保证并非对所有函数都可实现或具备实现意义。
函数提供的“异常安全保证”通常最高只等于其所调用各个函数的“异常安全保证”中的最弱者。

item 30: understand the ins and outs of inlining.

将大多数 inlining 限制在小型、被频繁调用的函数身上。这可使日后的调试过程和二进制升级更容易，也可使潜在的代码问题最小化，使程序的速度提升机会最大化。
不要只因为 function templates 出现在头文件，就将它们声明为 inline。

item 31: minimize compilation dependencies between files.

如果使用 object references 或 object pointers 可以完成任务，就不要使用 objects。
如果能够，尽量以 class 声明式替换 class 定义式。
为声明式和定义式提供不同的头文件。
使用 pimpl idiom 的 classes, 往往被称为 Handle classes。
另一个 Handle class 的办法是，继承一个特殊的 abstract base class，称为 interface class。
支持“编译依存性最小化”的一般构想是：相依于声明式，不要相依于定义式。基于此构想的两个手段是 Handle classes 和 Interface classes。
程序库头文件应该以“完全且仅有声明式”的形式存在。这种做法不论是否涉及 templates 都适用。

6. 继承与面向对象设计

item 32: make sure public inheritance models "is-a".

“public 继承”意味着 is-a。适用于 base classes 身上的每一件事情一定也适用于 derived classes 身上，因为每一个 derived class 对象也都是一个 base class 对象。

item 33: avoid hiding inherited names.

derived classes 内的名称会遮掩 base classes 内的名称。在 public 继承下从来没有人希望如此。
为了让被遮掩的名称再见天日，可使用 using 声明式或转交函数（forwarding functions）。

item 34: differentiate between inheritance of interface and inheritance of implementation.

成员函数的接口总是会被继承；
声明一个 pure virtual 函数的目的是为了让 derived class 只继承函数的接口；
声明简朴（非纯） impure virtual 函数的目的，是让 derived classes 继承该函数的接口和缺省实现。
接口继承和实现继承不同。在 public 继承之下，derived classes 总是继承 base class 的接口。
pure virtual 函数只具体指定接口继承。
简朴的（非纯）impure virtual 函数具体指定接口继承及缺省实现继承。
non-virtual 函数具体指定接口继承以及强制性实现继承。

item 35: consider alternatives to virtual functions.

藉由 Non-Virtual Interface 手法实现 Template Method 模式
藉由 Function Pointers 实现 Strategy 模式
藉由 tr1::function 实现 Strategy 模式（没看懂）
古典的 Strategy 模式
virtual 函数的替代方案包括 NVI 手法及 Strategy 设计模式的多种形式。 NVI 手法自身是一个特殊形式的 Template Method 设计模式。
将机能从成员函数移到 class 外部函数，带来的一个缺点是，非成员函数无法访问 class 的 non-public 成员。
tr1::function 对象的行为就像一般函数指针。这样的对象可接纳“与给定之目标签名式（target signature）兼容”的所有可调用物（callable entities）。

item 36: Never redefine an inherited non-virtual function.

绝对不要重新定义继承而来的 non-virtual 函数。

item 37: Never redefine a function's inherited default parameter value.

virtual 函数系动态绑定而来，意思是调用一个 virtual 函数时，究竟调用哪一份函数实现代码，取决于发出调用的那个对象的动态类型； - 绝对不要重新定义一个继承而来的缺省参数值，因为缺省参数值都是静态绑定，而 virtual 函数——你唯一应该覆写的东西——却是动态绑定。

item 38: Model "has-a" or "is-implemented-in-terms-of" through composition.

复合（composition）是类型之间的一种关系：一个对象内含其他类型的对象；
复合的意义和 public 继承完全不同；
在应用域（application domain），复合意味着 has-a （有一个）。在实现域（implementation domain），复合意味着根据某物实现出。

item 39: Use private inheritance judiciously.

由 private base class 继承而来的所有成员，在 derived class 中都会变成 private 属性，纵使它们在 base class 中原来是 protected 或 public 属性；
尽可能使用 item38 的复合，必要时才使用 private 继承；
private 继承意味着 is-implemented-in-terms-of （根据某物实现出）。它通常比复合的级别低。但是当 derived class 需要访问 protected base class 的成员，或需要重新定义继承而来的 virtual 函数时，这么设计是合理的；
和复合不同，private 继承可以造成 empty base 最优化。这对致力于“对象尺寸最小化”的程序库开发者而言，可能很重要。

item 40: Use multiple inheritance judiciously.

非必要不使用 virtual bases，平常请使用 non-virtual 继承；
如果必须使用 virtual base classes，尽可能避免在其中放置数据；
多重继承比单一继承复杂。它可能导致新的歧义性，以及对 virtual 继承的需要；
virtual 继承会增加大小、速度、初始化（及赋值）复杂度的成本。如果 virtual base classes 不带任何数据，将是最具有实用价值的情况；
多重继承的确有正当用途。其中一个情节涉及“public 继承某个 Interface class” 和“private 继承某个协助实现的 class”的两相组合。

7. 模板与泛型编程

item 41: Understand implicit interfaces and compile-time polymorphism.

面向对象编程世界总是以显示接口（explicit interfaces）和运行期多态（runtime polymorphism）解决问题；
Templates 及泛型编程与面向对象的不同在于隐式接口（implicit interfaces）和编译期多态（compile-time polymorphism）的重要性提升；
classes 和 templates 都支持接口（interfaces）和多态（polymorphism）；
对 classes 而言接口是显式的（explicit），以函数签名为中心。多态则是通过 virtual 函数发生于运行期；
对 template 参数而言，接口是隐式的（implicit），奠基于有效表达式。多态则是通过 template 具现化和函数重载解析（function overloading resolution）发生于编译期。

item 42: Understand the two meanings of typename.

声明 template 参数时，前缀关键字 class 和 typename 可互换；
请使用关键字 typename 标识嵌套从属类型名称；但不得在 base class lists（基类列）或 member initialization list（成员初值列）内以它作为 base class 修饰符。（查看书中例子）

item 43: Know how to access names in templatized base classes.

可在 derived class templates 内通过“this->”指涉 base class templates 内的成员名称，或藉由一个明白写出的“base class 资格修饰符”完成。

item 44: Factor parameter-independent code out of templates.

Templates 生成多个 classes 和多个函数，所以任何 template 代码都不该与某个造成膨胀的 template 参数产生相依关系；
因非类型模板参数（non-type template parameters）而造成的代码膨胀，往往可消除，做法是以函数参数或 class 成员变量替换 template 参数；
因类型参数（type parameters）而造成的代码膨胀，往往可降低，做法是让带有完全相同的二进制表述（binary representations）的具现类型（instantiation types）共享实现码。

item 45: Use member function templates to accept "all compatible types".

泛化（generalized）copy 构造函数；（隐式转换）
请使用 member function templates（成员函数模板）生成“可接受所有兼容类型”的函数；
如果你声明 member templates 用于“泛化 copy 构造”或“泛化 assignment 操作”，你还是需要声明正常的 copy 构造函数和 copy assignment 操作符。

item 46: Define non-member functions inside templates when type conversions are desired.

template 实参推导过程中，不考虑“通过构造函数而发生的”隐式类型转换；
许多编译器会强迫将所有 template 定义式放进头文件内；
当我们编写一个 class template，而它所提供之“与此 template 相关的”函数支持“所有参数之隐式类型转换”时，请将那些函数定义为“class template 内部的 friend 函数”。

item 47: Use traits classes for information about types. 【没看懂】

traits，又被叫做特性萃取技术，说得简单点就是提取“被传进的对象”对应的返回类型，让同一个接口实现对应的功能。因为STL的算法和容器是分离的，两者通过迭代器链接。算法的实现并不知道自己被传进来什么。萃取器相当于在接口和实现之间加一层封装，来隐藏一些细节并协助调用合适的方法，这需要一些技巧（例如，偏特化）。
Traits classes 使得“类型相关信息”在编译器可用。它们以 templates 和“templates 特化”完成实现；
整合重载技术（overloading）后，traits classes 有可能在编译期对类型执行 if…else 测试。

item 48: Be aware of template metaprogramming.

Template metaprogramming, TMP, 模板元编程；是编写 template-based C++ 程序并执行于编译期的过程；
由于 template metaprograms 执行于 C++ 编译期，因此可将工作从运行期转移到编译期。
- 某些错误原本通常在运行期才能侦测到，现在可在编译期找出来；因而得以实现早期错误侦测和更高的执行效率；
- 使用 TMP 的 C++ 程序：较小的可执行文件、较短的运行期、较少的内存需求；但编译时间可能远长于不使用 TMP 的对应版本；
TMP 可被用来生成“基于策略选择组合”（based on combinations of policy choices）的客户定制代码，也可用来避免生成对某些特殊类型并不适合的代码。

8. 定制 new 和 delete

item 49: Understand the behavior of the new-handler.

set_new_handler 允许客户指定一个函数，在内存分配无法获得满足时被调用；
Nothrow new 是一个颇为局限的工具，因为它只适用于内存分配；后继的构造函数调用还是可能抛出异常。

item 50: Understand when it makes sense to replace new and delete.

有许多理由需要写个自定的 new 和 delete，包括改善效率、对 heap 运用错误进行调试、收集 heap 使用信息。

item 51: Adhere to convention when writing new and delete.

C++ 保证“删除 null 指针永远安全”；
operator new 应该内含一个无穷循环，并在其中尝试分配内存，如果它无法满足内存需求，就该调用 new-handler。它也应该有能力处理 0 bytes 申请。Class 专属版本则还应该处理“比正确大小更大（错误）的申请”；
operator delete 应该在收到 null 指针时不做任何事。Class 专属版本则还应该处理“比正确大小更大的（错误）申请”。

item 52: Write placement delete if you write placement new.

如果 operator new 接受的参数除了一定会有的 size_t 之外还有其他，这便是所谓的 placement new。
当你写一个 placement operator new，请确定也写出了对应的 placement operator delete。如果没有，你的程序可能会发生隐威而时断时续的内存泄露；
当你声明 placement new 和 placement delete，请确定不要无意识（非故意）地遮掩了它们的正常版本。

9. 杂项讨论

item 53: Pay attention to compiler warnings.

严肃对待编译器发出的警告信息。努力在你的编译器的最高（最严苛）警告级别下争取“无任何警告”的荣誉；
不要过度依赖编译器的报警能力，因为不同的编译器对待事情的态度并不形同。一旦移植到另一个编译器上，你原本依赖的警告信息有可能消失。

item 54: Familiarize yourself with the standard library, including TR1.

C++ 标准程序库的主要机能由 STL、iostreams、locales 组成。并包含 C99 标准程序库。
TR1 添加了智能指针（例如：tr1::shared_ptr）、一般化函数指针（tr1::function）、hash-based 容器、正则表达式（regular expressions）以及另外 10 个组件的支持；
TR1 自身只是一份规范。为获得 TR1 提供的好处，你需要一份实物。一个好的实物来源是 Boost。

item 55: Familiarize yourself with Boost.