C++ 改善程序与设计的55个方法

1 尽量以const、enum、inline替换#define，其实质是尽量以编译器替换预处理器。

• 用宏定义的一个问题比如：宏定义的内容，不会进入记号表，这会给调试带来麻烦。
• C++头文件中的常量定义式，是可以被多个源文件包含的。
• 关于class中的专属常量问题，需要声明成static const格式，且需要在非头文件中定义下这个变量。声明和定义中，只能对其初始化一次。
  • 最好用line替代#define定义的形式函数的宏

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

最好用line替代#define定义的形式函数的宏。

2 尽可能使用const

C++ 中，可以对返回为用户自定义类型的右值进行赋值操作。

因此，下面这段代码是合法的，虽然不常见。

class Rational {
};

Rational operator* (const Rational& lhs, const Rational& rhs) {
	return lhs;
}
Rational a, b, c;
(a * b) = c;

最后一条赋值语句没有意义，这样写，往往是用户写错了，比如少写了一个等于号。

但是如果Rational是内置类型，则最后一条语句非法。为了保持和内置类型的兼容，最好是将函数返回值的类型定义为const类型。

如果没有必要的理由，要将函数返回值和参数都声明为const类型。参数声明为const的还一个好处是可以接收const对象。

如果没有必要的理由，将成员函数实施于const，原因是：1，使class接口比较容易被理解，可以容易得知哪个函数可以改动对象而哪个不行。2，使操作const对象成为可能。
如果两个成员函数只是常量性不同，可以被重载。

1. 将某些东西声明为const可以帮助编译器侦测出错误用法。
2. 编译器强制实施bitwise constness，但是你编写程序时应该使用“概念上的常量性”
3. 当const和non-const成员函数有着实质等价的实现时，令non-const 版本调用const版本可以避免代码重复。

3 确定对象被使用前已经先被初始化

class中成员初始化次序：base class更早于其derived classes被初始化，而class的成员变量总是以其声明次序被初始化。

如果某个编译单元内的某个non-local static对象的初始化动作使用了另一编译单元内的某个non-local static对象，它所用到的这个对象可能尚未被初始化，因为C++对"定义于不同编译单元内的non-local static对象"的初始化次序没有明确定义。

1. 对于内置类型对象，要手动保证初始化的对象
2. 对于类成员，尽量在初始化列表初始成员变量
3. 不要使用一个文件中的non-static 对象初始化另一个文件中的对象

二 构造/析构/赋值运算

4 编译器自动生成类函数规则

其他：

只有生成的代码合法且有适当机会证明它有意义时，才会自动生成。如果base classes将copy assignment声明为private，其对应的derived classes也会拒绝生成一根copy assignment。，因为它无法调用base classes的copy assignment。

5 若不想使用编译器自动生成的函数，应该明确拒绝

1. 如果想禁止编译器自动生成某些函数，最好是主动声明这些函数且将其指定为delete。
2. 可以通过继承一个专门为了阻止copying、moving动作而设计的base class 来禁止这些函数的生成。

6 为多态基类声明virtual析构函数

1. 带多态性质的base classes应该声明一根virtual析构函数。如果class带有任何virtual函数，它就应该拥有一个virtual析构函数
2. 如果类的设计目的不是作为基类被使用，就不应该声明virtual析构函数

7 别让异常逃离析构函数

1. 如果析构函数吐出异常，程序可能会过早结束或发生不明确行为的风险。如果一个被析构函数调用的函数可能抛出异常，析构函数应该捕捉任何异常，然后吞下它们（不传播）或结束程序。
2. 如果客户需要对某个操作函数运行期间抛出的异常做出反应，那么class应该提供一个普通函数（而非析构函数中）执行该操作。

8 绝不在构造和析构过程中调用virtual函数

在构造和析构期间不要调用virtual函数，因为这类调用从不下降至derived class(比起当前执行构造函数和析构函数的那层)。

9 令operator=返回一个reference to *this

10 在operator=中处理“自我赋值”

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

11 复制对象时勿忘记其每一个成分

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

三 资源管理

1 以对象管理资源

为防止资源泄漏，请使用RAII对象，它们在构造函数中获得资源并在析构函数中释放资源

2 在资源管理类中小心copying行为

资源管理类中的copying行为一般有四种方式：

1. 禁止复制
2. 对底层资源祭出“引用计数法”
3. 复制底部资源
4. 转移底部资源的拥有权

3 在资源管理类中提供对原始资源的访问

建议使用显示转换的方式，因为它比较安全。

4 以独立语句将newed对象存储在智能指针中

四 设计与声明

1 让接口容易被正确使用

1. 让接口拥有一致性，与内置类型的行为兼容
2. 通过建立新类型、限制类型上的操作，束缚对象值，以及消除客户的资源管理责任
3. 通过std::shared_ptr支持定制型删除器来防范DLL问题

2 设计class犹如设计type

1. 新type的对象应该如何被创建和销毁
2. 对象的初始化和对象的赋值该有什么样的差别
3. 新type的对象如果被passed by value，意味着什么
4. 什么是新type的“合法值”
5. 你的新type需要配合某个继承图系吗
6. 你的新type需要什么样的转换
7. 什么样的操作符和函数对此新type而言是合理的
8. 什么样的标准函数应该驳回
9. 谁该取用新type的成员
10. 什么是新type的“未声明接口”
11. 你的新type有多么一般化
12. 你真的需要一个新type吗

3 尽量以pass-by-reference-to-const替换pass-by-value

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

4 必须返回对象时，别妄想返回其reference

5 将成员变量声明为private

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

6 宁以non-member non-friend替换member函数

因为non-member non-friend比member函数能导致更大的数据封装度。

7 若所有参数皆需类型转换，请为此采用non-member函数

对于支持被定义的class的运算符函数，应该被设置为non-member函数

8 考虑写出一个不抛出异常的swap函数

1. 当std::swap对你的类型效率不高时，提供一个swap成员函数，并确定这个函数不抛出异常。因为swap的一个最好的应用就是帮助classes或class templates提供强烈的异常安全性保障。这只针对成员版，不针对非成员版，因为swap缺省版本是以copy构造函数和copy assignment操作符为基础的，而一般情况下两者都允许抛出异常。
2. 如果你提供一个member swap，也应该提供一个non-member swap用来调用前者。对于classes（而非templates），也请特化std::swap。
3. 调用swap时应针对std::swap使用using声明式，然后调用swap并且不带任何“命名空间资格修饰”
4. 为“用户定义类型”进行std templates全特化是好的，但千万不要尝试在std内加入某些对std而言全新的东西。

五 实现

1 尽可能延后变量定义式出现时间

尽量在直到非得使用该变量的前一刻，且直到能够给它初值参数的前一刻为止，再定义这个变量，同时初始化它。

2 尽量少做转型动作

C++提供了四种新式转型：

• const_cast(expression): 被用来将对象的常量性转除。它也是唯一有此能力的C++style转型操作符。
• dynamic_cast主要用来执行“安全向下转型”，也就是用来决定某对象是否归属继承体系中的某个类型。它是唯一可能耗费重大运行成本的转型动作。
• reinterpret_cast: 意图执行低级转型， 实际动作取决于编译器，这也表明其不可移植。
• static_cast: 用来强迫隐式转换。

1. 尽量避免转型，特别是在注重效率的代码中避免dynamic_casts。如果有个设计需要转型动作，试着发展无需转型的代替设计。
2. 如果转型是必要的，试着将它隐藏于某个函数背后。客户随后可以调用该函数，而不需要将转型放进他们自己的代码中。
3. 尽量使用C++style转型，不要使用旧式转型。前者很容易辨识出来，而且也比较有着分门别类的职掌。

3 避免返回handles指向对象内部成分

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

4 为“异常安全”而努力是值得的

“异常安全有两个条件”：

当异常被抛出时，带有异常安全性的函数会：

• 不泄露任何资源。
• 不允许数据败坏。

异常安全函数提供以下三个保证之一：

• 基本承诺：如果异常被抛出，程序内的任何事物仍然保持在有效状态下，但是程序的现实状态不可预料
• 强烈保证：如果异常被抛出，程序状态不改变
• 不抛掷保证：承诺绝不抛出异常

1. 异常安全函数即使发生异常也不会泄漏资源或允许任何数据结构败坏。这个的函数区分为三种可能的保证：基本型、强烈型、不抛异常型
2. “强烈保证”往往能够以copy-and-swap实现出来，但是“强烈保证”并非对所有函数都可实现或具备现实意义。
3. 函数提供的“异常安全保证”通常最高只等于其所调用之各个函数的“异常安全保证”中的最弱者。

5 透彻了解inlining的里里外外

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

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

6 将文件间的编译依存关系降至最低

1. 支持“编译依存性最小化”的一般构想是：相依于声明式，不要相依于定义式。基于此构想的两个手法是Handle classes和Interface classes。
2. 程序库头文件应该以“完全且仅有声明式“的形式存在。这种做法不论是否涉及到templates都试用。

五 继承与面向对象设计

1 确定你的public继承塑模出is-a关系

如果class D以public形式继承class B，便是告诉编译器，每一个类型为D的对象同时也是一个类型为B的对象，反之不成立。B对象可派上用场的任何地方，D对象一样可以派上用场。

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

2 避免遮掩继承而来的名称

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

3 区分接口继承和实现继承

1. pure virtual 函数只具体指定接口继承。
2. impure virtual函数具体指定接口继承及缺省实现继承
3. non-virtual函数具体指定接口继承以及强制性实现继承。

4 考虑virtual函数以外的其他选择

NVI手法。derived class可以重新定义继承而来的private virtual函数，但是不能使用它们。

• 使用non-virtual interface(NVI)手法，那是Template Method设计模式的一种特殊形式。它以public non-virtual成员函数包裹较低访问性的virtual函数。
• 将virtual函数替换为“函数指针成员变量”，这是Strategy设计模式的一种分解表现形式。
• 以std::function成员变量替换virtual函数，因而允许任何可调用物搭配一个兼容于需求的签名式。这也是Strategy设计模式的某种形式。
• 将继承体系内的virtual函数替换为另一个继承体系内的virtual函数，这是Strategy设计模式的传统实现手法。

1. virtual函数的替代方案包括NVI手法及Strategy设计模式的多种形式。NVI手法自身是一个特殊形式的Template Method设计模式。
2. 将机能从成员函数移到class外部函数，带来的一个缺点是，非成员函数无法访问class的non-public成员。
3. std::function对象的行为就像一般函数指针。这样的对象可接纳“与给定之目标签名式兼容”的所有可调用物。

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

6 绝不重新定义继承而来的缺省参数值

virtual函数系动态绑定，而缺省参数值却是静态绑定。

绝对不要重新定义一个继承而来的缺省参数值，因为缺省参数值都是静态绑定，而virtual函数——你唯一应该覆写的东西——却是动态绑定。

7 通过符合塑模出has-a或“根据某物实现出”

1. 复合的意义和public继承完全不同
2. 在应用域，复合意味has-a。在实现域，复合意味is-implemented-in-terms-of。

8 明智而审慎地使用private继承

如果classes之间的继承关系是private，编译器不会自动将一个derived class对象转换为一个base class对象。由private base class继承而来的所有对象，在derived class中都会变成private属性，纵使它们在base class中原本是protected或public属性。

EBO（empty base optimization）：如果一个类不带任何数据，及这样的class没有non-static成员变量，没有virtual函数（这种函数的存在会为每个对象带来一根vptr），也没有virtual base class，这种类便是一根empty classes, 对象不适用任何空间。但是由于技术上的理由，C++裁定凡是独立的对象，都必须有非零大小，所以一个empty classes的对象，大小至少为1个字节，有些编译器可能会将其放大到4个字节。

但是，如果empty classes被继承，那这个空类不增加派生类任何大小，这便是EBO。需要注意的是，EBO一般只在单一继承下才行。

1. private继承意味is-implemented-in-terms of（根据某物实现出）。它通常比复合的级别低。但是当derived class需要访问protected base class的成员，或需要重新定义继承而来的virtual函数时，这么设计是合理的。
2. 和复合不同，private继承可以造成empty base最优化。这对致力于“对象尺寸最小化”的程序库开发者而言，可能很重要。

9 明智而审慎地使用多重继承

C++用来解析重载函数调用的规则：在看到是否有个函数可取用之前，C++首先确认这个函数对此调用之言是最佳匹配，找出最佳匹配函数后才检验其可取用性。

钻石型多重继承：两种方案：缺省方案是执行复制，也可以让带有此数据的class成为一个virtual base class。

使用virtual继承的那些classes所产生的对象往往比使用non-virtual继承的兄弟们体积大，访问virtual base classes的成员变量时，也比访问non-virtual base classes的成员变量速度慢。

1. 多重继承比单一继承复杂。它可能导致新的歧义性，以及对virtual继承的需要。
2. virtual继承会增加大小、速度、初始化（及赋值）复杂性等等成本。如果virtual base classes不带任何数据，将是最具实用价值的情况。
3. 多重继承的确有正当用途。其中一个情节涉及“public 继承某个Interface clas” 和”private继承某个协助实现的class“的两相组合。

六 模板与泛型编程

1 了解隐式接口和编译器多态

运行期多态

编译器多态：以不同的template参数具现化会导致调用不同的函数。

1. classes和templates都支持接口和多态
2. 对classes而言接口是显式的，以函数标签名为中心。多态则是通过virtual函数发生于运行期。
3. 对template参数而言，接口是隐式的，奠基于有效表达式。多态则是通过template具现化和函数重载解析发生于编译器。

2 了解typename的双重意义

如果解析器在template中遭遇一个嵌套从属名称，它便假设这是名称不是类型，及缺省情况下嵌套从属名称不是类型。

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

3 学习处理模板化基类内的名称

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

4 将与参数无关的代码抽离templates

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

5 运用成员函数模板接受所有兼容类型

member temlates并不改变语言规则。在class内声明泛化copy构造函数并不会组织编译器生成它们自己的copy构造函数。

1. 请使用member function templates 生成“可接受所有兼容类型”的函数。
2. 如果你声明member templates 用于“泛化copy构造” 或 “泛化assignment操作”， 你还是需要声明正常的copy构造函数和copy assignment操作符。

6 需要类型转换时请为模板定义非成员函数

template实参推导过程中从不将隐式类型转换函数纳入考虑。

当编写一个class template，而它所提供之“于此template相关的”函数支持“所有参数之隐式类型转换”时，请将那些函数定义为“class template 内部的friend函数”。

7 请使用traits class表现类型信息

Traits：允许你在编译期间取得某些类型信息。

1. Traits classes使得”类型相关信息“在编译器可用。它们以templates和”templates特化“完成实现。
2. 整合重载技术（overloading）后，traits classes有可能在编译器对类型执行if…else测试。

8 认识template元编程

1. TMP（模板元编程）可将工作由运行期移往编译器，因而得以实现早期错误侦测和更高的执行效率。
2. TMP可被用来生成”基于政策选择组合“的客户定制代码，也可用来避免生成对某些特殊类型并不合适的代码。

七 定制new和delete

一 了解new-handler的行为

CRTP（怪异的循环模板模式）

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

二 了解new 和 delete的合理替换时机

写一个自定义的new和delete的理由：

1. 为了检测运用错误
2. 为了收集动态分配内存之使用统计信息
3. 为了增加分配和归还的速度
4. 为了降低缺省内存管理器带来的空间额外开销
5. 为了弥补缺省分配器中的非最佳齐位
6. 为了将相关对象成簇集中
7. 为了获得非传统行为

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

三 编写new和delete时需要固守常规

缺省的operator new会在每次失败后调用new-handling函数，然后再次尝试分配内存。只有当new-handling函数指针是null，operator new才会抛出异常。

C++规定，即使客户要求申请0 bytes内存，operator new也得返回一个合法指针。

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

四 写了placement new也要写placement delete

1. 当你写了一个placement operator new，请确定也写出了对应的placement operator delete。如果没有这么做，你的程序可能会发生隐微而时断时续的内存泄露。
2. 当你声明placement new和placement delete，请确定不要无意识的遮掩了它们的正常版本。

八 杂项讨论

一 不要轻易忽略编译器的警告

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

二 让自己熟悉boost