Effective C++

目錄

介紹	0
Preface（前言）	1
Introduction（导言）	2
Terminology（术语）	3
Item 1: 将 C++ 视为 federation of languages（语言联合体）	4
Item 2: 用 consts, enums 和 inlines 取代 #defines	5
Item 3: 只要可能就用 const	6
Item 4: 确保 objects（对象）在使用前被初始化	7
Item 5: 了解 C++ 为你偷偷地加上和调用了什么函数	8

Item 6: 如果你不想使用 compiler-generated functions（编译器生成函数），就明确拒绝

Item 7: 在 polymorphic base classes（多态基类）中将 destructors（析构函数）声明 9

为 virtual（虚拟）	10
Item 8: 防止因为 exceptions（异常）而离开 destructors（析构函数）	11
Item 9: 绝不要在 construction（构造）或 destruction（析构）期间调用 virtual
functions（虚拟函数）	12
Item 10: 让 assignment operators（赋值运算符）返回一个 reference to \*this（引向
\*this 的引用）	13
Item 11: 在 operator= 中处理 assignment to self（自赋值）	14
Item 12: 拷贝一个对象的所有组成部分	15
Item 13: 使用对象管理资源	16
Item 14: 谨慎考虑资源管理类的拷贝行为	17
Item 15: 在资源管理类中准备访问裸资源（raw resources）	18
Item 16: 使用相同形式的 new 和 delete	19
Item 17: 在一个独立的语句中将 new 出来的对象存入智能指针	20
Item 18: 使接口易于正确使用，而难以错误使用	21
Item 19: 视类设计为类型设计	22

Item 20: 用 pass-by-reference-to-const（传引用给 const）取代 pass-by-value（传值）

Item 21: 当你必须返回一个对象时不要试图返回一个引用	24 23
Item 22: 将数据成员声明为 private		25
Item 23: 用非成员非友元函数取代成员函数	26
Item 24: 当类型转换应该用于所有参数时，声明为非成员函数		27

2

Effective C++

Item 25: 考虑支持不抛异常的 swap	28
Item 26: 只要有可能就推迟变量定义	29
Item 27: 将强制转型减到最少	30
Item 28: 避免返回对象内部构件的“句柄”	31
Item 29: 争取异常安全（exception-safe）的代码	32
Item 30: 理解 inline 化的介入和排除	33
Item 31: 最小化文件之间的编译依赖	34
Item 32: 确保 public inheritance 模拟 "is-a"	35
Item 33: 避免覆盖（hiding）“通过继承得到的名字”	36

Item 34: 区分 inheritance of interface（接口继承）和 inheritance of implementation（实

现继承）	37
Item 35: 考虑可选的 virtual functions（虚拟函数）的替代方法	38
Item 36: 绝不要重定义一个 inherited non-virtual function（通过继承得到的非虚拟函
数）	39

Item 37: 绝不要重定义一个函数的 inherited default parameter value（通过继承得到的缺

省参数值）

40

Item 38: 通过 composition（复合）模拟 "has-a"（有一个）或 "is-implemented-in-terms-

of"（是根据……实现的）	41
Item 39: 谨慎使用 private inheritance（私有继承）	42
Item 40: 谨慎使用 multiple inheritance（多继承）	43

Item 41: 理解 implicit interfaces（隐式接口）和 compile-time polymorphism（编译期多

	态）	44
	Item 42: 理解 typename 的两个含义	45
	Item 43: 了解如何访问 templatized base classes（模板化基类）中的名字	46
	Item 44: 从 templates（模板）中分离出 parameter-independent（参数无关）的代码
	Item 45: 用 member function templates（成员函数模板） 接受 "all compatible	47
	types"（“所有兼容类型”）	48
	Item 46: 需要 type conversions（类型转换）时在 templates（模板）内定义 non-
	member functions（非成员函数）	49
	Item 47: 为类型信息使用 traits classes（特征类）	50
	Item 48: 感受 template metaprogramming（模板元编程）	51
	Item 49: 了解 new-handler 的行为	52
	Item 50: 领会何时替换 new 和 delete 才有意义	53
	Item 51: 编写 new 和 delete 时要遵守惯例	54
	Item 52: 如果编写了 placement new，就要编写 placement delete	55

3

Effective C++

附录 A. 超越 Effective C++	56
附录 B. 第二和第三版之间的 Item 映射	57

4

Effective C++

Effective C++

作者：Scott Meyers

译者：fatalerror99 (iTePub's Nirvana)

来源：http://blog.csdn.net/fatalerror99/

介紹

5

Effective C++

Preface（前言）

作者：Scott Meyers

译者：fatalerror99 (iTePub's Nirvana)

发布：http://blog.csdn.net/fatalerror99/

我在 1991 年写出了 Effective C++ 的最早版本，1997 年出了第二版，我更新了一些重要的方 面的素材，但是，因为我不想使熟悉本书第一版的读者感到困惑，我尽最大可能保持了原有 的结构。最早的 50 个 Item 标题中的 48 个原则上保持不变。如果把书看作一栋房子，第二版 就相当于通过更换地毯、涂料和灯光设备等使其焕然一新。

对于第三版，我打散了原有的秩序。（很多次我希望我能做得更彻底。）1991 年以来，C++ 世界经历了巨大的改变，而将近 15 年以前我制定的那些 Item 也不再契合本书的目标——将 最重要的 C++ 编程准则融入小而易读的建议中。1991 年，假设 C++ 程序员具有 C 语言背景 是有一定道理的。现在，转到 C++ 的程序员很可能来自 Java 或 C#。1991 年， inheritance（继承）和 object-oriented programming（面向对象编程）对于大多数程序员来 说都是新鲜的。现在，这些已经是非常普遍的概念，而 exceptions（异常），templates（模 板），以及 generic programming（泛型编程）成为新的需要更多指导的领域。1991 年，没 有人听说过 design patterns（设计模式）。现在，讨论软件系统时很难不涉及它们。1991 年，C++ 正式标准化的工作刚刚开始。现在，标准化已经八年了，而下一个版本的工作也已 经开始。

为应对这些变化，我尽己所能将写字板擦得一干二净，并不断地追问自己：“在 2005 年，对 于目前的 C++ 程序员，什么才是最重要的建议？”结果就是这个新版本中的一组 Item。本书 包括了关于 resource management（资源管理）和 programming with templates（使用模板 编程）的新的章节。实际上，templates（模板）的考虑贯穿全书，因为它几乎影响了 C++ 的 每个方面。本书也包括关于在 exceptions（异常）存在的场合下编程，在应用 design patterns（设计模式），以及在使用新的 TR1 库程序（TR1 在 Item 54 中介绍）等方面的新 的素材。本书还承认在 single-threaded systems（单线程系统）中能很好地工作的技术和方 法可能不适用于 multithreaded systems（多线程系统）。噢，本书超过一半的素材都是新 的。然而，第二版中基本原理方面的资料中的大部分依然是重要的，所以我将它们以这样或 那样的形式保留下来。（你能在 Appendix B（附录 B）找到第二版和第三版 Item 的对照

表。）

我尽我所能使本书趋于最好，但我并不幻想完美。如果你觉得本书中的一些 Item 作为常规的 建议不太合适；或者有更好的方法实现本书中需要完成的任务；或者有一个或更多技术上的 讨论不明确，不完全，或容易令人误解，请告诉我。如果你发现任何错误——技术上的，文 法上的，印刷上的，无论哪种——也请告诉我。如果你是第一个让我注意到某个问题的人， 我很高兴将你的名字加入到以后再次印刷的致谢中。

Preface（前言）

6

Effective C++

即使 Item 的数量增加到 55，本书中的这一组准则离完满无遗还差得很远。但是成为好的规则 ——在几乎所有的应用程序几乎所有的时间中得到应用——比它看上去更加困难。如果你有 增加准则的建议，我很高兴能听到它。

我维护本书从第一次印刷起的变化列表，包括错误修正，进一步解释，和技术更新。这个列 表可以从 Effective C++ Errata 网页得到，http://aristeia.com/BookErrata/ec++3e- errata.html。如果你希望当我更新列表时，你能得到通报，我建议你参加我的 mailing list（邮 件列表）。我用它作为通告，发给那些对跟踪我的职业工作感兴趣的人们。关于细节问题， 请参考 http://aristeia.com/MailingList/。

SCOTT DOUGLAS MEYERS STAFFORD, OREGON http://aristeia.com/ APRIL 2005

Preface（前言）

7

Effective C++

Introduction（导言）

作者：Scott Meyers

译者：fatalerror99 (iTePub's Nirvana)

发布：http://blog.csdn.net/fatalerror99/

学习一种编程语言的基础是一回事；学习如何用那种语言设计和实现高效率的程序完全是另 外一回事。对于 C++ ——一种以拥有非同寻常的能力范围和表现力而自豪的语言——更是尤 其如此。如果能正确使用，与 C++ 共事是一件令人快乐的事情。极多样的设计样式被直接表 达并有效实现。对于 classes（类），functions（函数），以及 templates（模板）的明智选 择和小心精巧的安排能使应用程序的编程更加简单，直观，高效，并基本无错。如果你知道 如何去做，写出高效的 C++ 程序并不特别难。然而，如果不经训练就贸然使用，C++ 也会导 致不可理解的，难以维护的，无法扩展的，低效率的，错误百出的代码。

本书的目的在于引导你如何高效使用 C++。我假设你已经熟悉了作为语言的 C++ 并有使用它 的一些经验。我在此提供的是使用这种语言的指南，以使你的程序易于理解，可维护，易移 植，可扩展，效率高，而且行为符合你的预期。

我提供的建议落在两个主要的范围中：普通的设计策略，以及特殊语言特性的具体细节。设 计的讨论集中于如何在 C++ 做某件事情的多种不同方法之间进行选择。如何在 inheritance（继承）和 templates（模板）之间选择？如何在 public（公有）和 private inheritance（私有继承）之间选择？如何在 private inheritance（私有继承）和 composition（复合）之间选择？如何在 member（成员）和 non-member functions（非成员 函数）之间选择？如何在 pass-by-value（传值）和 pass-by-reference（传引用）之间选择？ 在一开始就做出正确的决定是很重要的，因为一个不好的选择可能会直到开发过程很晚的阶 段才显现出来，在这时候再调整它常常是困难重重，极为耗时而且代价不菲的。

即使在你正确地知道你要做什么的时候，仅仅把事情做对也是需要技巧的。assignment operators（赋值运算符）的合适的返回类型是什么？destructor（析构函数）什么时候应该是 virtual（虚拟）的？当 operator new（运算符 new）找不到足够的内存时它应该怎么办？类似 这些的令人费神的细节是至关重要的，因为错误的做法几乎总是导致无法预料的，很可能令 人迷惑的程序行为。这本书正是来帮助你避免这些问题的。

这不是一本全面的 C++ 手册。它收集了 55 个详细的提议（我将它们称为 Items）告诉你怎样 才能改善你的程序和设计。每一个 Item 都能 stands more or less on its own（独立成章）， 但大部分也包含对其它 Items 的参考。因而，读这本书的一个方法就是从你感兴趣的一个 Item 开始，然后顺着它的参考条目继续看下去。

Introduction（导言）

8

Effective C++

这本书也不是一本 C++ 入门书。例如，在 Chapter 2（第二章），我希望能告诉你关于 constructors（构造函数），destructors（析构函数），以及 assignment operators（赋值运 算符）正确实现的全部内容，但是我假设你已经知道或者能在别处找到这些函数做些什么以 及它们该怎样声明的资料。大量 C++ 书籍包含类似这样的信息。

这本书的目的是为了突出 C++ 编程中那些常常被忽略的方面。其它书描述了语言的各个部 分。这本书则告诉你如何将这些部分结合起来以达到高效编程的最终目的。其它书告诉你如 何使你的程序能够编译。这本书则告诉你如何避免那些编译器不能告诉你的问题。

与此同时，本书将自己限制在 standard C++（标准 C++）之内。在此仅仅使用官方的语言标 准中的特性。可移植性是本书一个关键的关注点，所以如果你要寻找平台依赖的特性和部 件，在这里不会找到。

另一个在本书中找不到的东西是 C++ Gospel（C++ 福音书）——通向完美的 C++ 软件的一

条One True Path（真理之路）。本书中的每一个 Item 都在如何生成更好的设计，如何避免 一般的问题，以及如何得到更高的效率等方面提供指导，但没有一个 Item 是普遍适用的。软 件设计和实现是一项复杂的任务，被 hardware（硬件），operating system（操作系统）， 和 application（应用程序）的限制所影响，所以我能做的最好的事情就是为创建更好的程序 提供 guidelines（指导方针）。

如果你在所有的时候都遵守这些 guidelines（指导方针），你将不太可能落入环绕在 C++ 周 围的大量陷阱中，但是作为 guidelines（指导方针）的固有限制，它总有例外。这就是为什么 每一个 Item 都有一个详细的解释。这些解释是本书中最重要的部分。只有理解了一个 Item 背后的基本原理，你才能决定它是否适合你开发的软件以及你被困其下的特有的限制。

本书最好用来增加关于 C++ 如何运转，为什么它会这样运转，以及如何让它的行为为你服务 等方面的知识。盲目运用本书的 Items 无疑是不适当的，但是与此同时，如果你没有更好的 理由，或许也不应该违反这些 guidelines（指导方针）中的任何一条。

Introduction（导言）

9

Effective C++

Terminology（术语）

作者：Scott Meyers

译者：fatalerror99 (iTePub's Nirvana)

发布：http://blog.csdn.net/fatalerror99/

这是一个所有程序员都应该了解的小型的 C++ vocabulary（词汇表）。下面的术语都足够重 要，对它们的含义取得完全一致对于我们来说是完全必要的。

declaration（声明）告诉编译器关于某物的 name（名字）和 type（类型），但它省略了某些 细节。以下这些都是 declaration（声明）：

extern int x; // object declaration

std::size_t numDigits(int number); // function declaration class Widget; // class declaration template<typename T> // template declaration

class GraphNode; // (see Item 42 for info on // the use of "typename")

注意即使是 built-in type（内建类型），我还是更喜欢将整数 x 看作一个 "object"，某些人将 "object" 这个名字保留给 user-defined type（用户定义类型），但我不是他们中的一员。再有 就是注意函数 numDigits 的返回类型是 std::size_t，也就是说，namespace（命名空间）std 中的 size_t 类型。这个 namespace（命名空间）是 C++ 标准库中每一样东西实际所在的地 方。但是，因为 C 标准库（严谨地说，来自于 C89）在 C++ 中也能使用，从 C 继承来的符 号（诸如 size_t）可能存在于全局范围，或 std 内部，或两者都有，这依赖于哪一个头文件被 #include。在本书中，我假设 C++ 头文件被 #include，这也就是为什么我用 std::size_t 代替 size_t 的原因。当文字讨论中涉及到标准库组件时，我一般不再提及 std，这依赖于你认可类

似size_t，vector，以及 cout 之类的东西都在 std 中，在示例代码中，我总是包含 std，因为 真正的代码没有它将无法编译。

顺便说一下，size_t 仅仅是供 C++ 对某物计数时使用的某些 unsigned 类型的 typedef（例 如，一个 char*-based string（基于 char* 的 string）中字符的个数，一个 STL container（容 器）中元素的个数，等等）。它也是 vector，deque，和 string 的 operator[] 函数所持有的类 型，这是一个在 Item 3 中定义我们自己的 operator[] 函数时将要遵守的惯例。

每一个函数的 declaration（声明）都表明了它的 signature（识别特征），也就是它的参数和 返回类型。一个函数的 signature（识别特征）与它的类型相同。对于 numDigits 的情况， signature（识别特征）是 std::size_t (int)，也就是说，“函数取得一个 int，并返回一个

Terminology（术语）

10

Effective C++

std::size_t”。官方的 "signature"（识别特征）的 C++ 定义排除了函数的返回类型，但是在本 书中，将返回类型考虑为 signature（识别特征）的一部分更加有用。

definition（定义）为编译器提供在 declaration（声明）时被省略的细节。对于一个

object（对象），definition（定义）是编译器为 object（对象）留出内存的地方。对于一个 function（函数）或一个 function template（函数模板），definition（定义）提供代码本体。 对于一个 class（类）或一个 class template（类模板），definition（定义）列出了 class（类）或者 template（模板）的 members（成员）：

int x; // object definition

std::size_t numDigits(int number) // function definition. { // (This function returns

std::size_t digitsSoFar = 1; // the number of digits // in its parameter.)

while ((number /= 10) != 0) ++digitsSoFar; return digitsSoFar;

}

class Widget { // class definition public:

Widget();

~Widget();

...

};

template<typename T> // template definition class GraphNode {

public:

GraphNode();

~GraphNode();

...

};

Terminology（术语）

11

Effective C++

initialization（初始化）是设定一个 object（对象）的第一个值的过程。对于 user-defined types（用户定义类型）的 objects（对象），initialization（初始化）通过 constructors（构造 函数）完成。default constructor（缺省构造函数）就是不需要任何 arguments（引数）就可 以调用的那一个。这样的一个 constructor（构造函数）既可以是没有 parameters（参数）， 也可以是每一个 parameter（参数）都有缺省值：

class A { public:

A(); // default constructor };

class B { public:

explicit B(int x = 0, bool b = true); // default constructor; see below }; // for info on "explicit"

class C { public:

explicit C(int x); // not a default constructor };

这里 classes B 和 C 的 constructors（构造函数）都被声明为 explicit（显式）。这是为了防 止它们被用来执行 implicit type conversions（隐式类型转换），虽然他们还可以被用于 explicit type conversions（显示类型转换）：

Terminology（术语）

12

Effective C++

void doSomething(B bObject); // a function taking an object of

// type B

B bObj1; // an object of type B

doSomething(bObj1); // fine, passes a B to doSomething

B bObj2(28); // fine, creates a B from the int 28

// (the bool defaults to true)

doSomething(28); // error! doSomething takes a B,

//not an int, and there is no

//implicit conversion from int to B

doSomething(B(28)); // fine, uses the B constructor to

//explicitly convert (i.e., cast) the

//int to a B for this call. (See

//Item 27 for info on casting.)

constructors（构造函数）被声明为 explicit（显式）通常比 non-explicit（非显式）更可取， 因为它们可以防止编译器执行意外的（常常是无意识的）type conversions（类型转换）。除 非我有一个好的理由允许一个 constructor（构造函数）被用于 implicit type conversions（隐 式类型转换），否则我就将它声明为 explicit（显式）。我希望你能遵循同样的方针。

请注意我是如何突出上面的示例代码中的 cast（强制转换）的。贯穿本书，我用这样的突出 引导你注意那些应该注意的材料。（我也突出章节号码，但那仅仅是因为我想让它好看一 些。）

copy constructor（拷贝构造函数）被用来以一个 object（对象）来初始化同类型的另一个 object（对象），copy assignment operator（拷贝赋值运算符）被用来将一个 object（对 象）中的值拷贝到同类型的另一个 object（对象）中：

class Widget {

public:

Widget(); // default constructor

Widget(const Widget& rhs); // copy constructor

Widget& operator=(const Widget& rhs); // copy assignment operator

...

};

Widget w1; // invoke default constructor

Widget w2(w1); // invoke copy constructor

w1 = w2; // invoke copy

// assignment operator

Terminology（术语）

13

Effective C++

当你看到什么东西看起来像一个 assignment（赋值）的话，要仔细阅读，因为 "=" 在语法上 还可以被用来调用 copy constructor（拷贝构造函数）：

Widget w3 = w2; // invoke copy constructor!

幸运的是，copy constructor（拷贝构造函数）很容易从 copy assignment（拷贝赋值）中区 别出来。如果一个新的 object（对象）被定义（就象上面那行代码中的 w3），一个 constructor（构造函数）必须被调用；它不可能是一个 assignment（赋值）。如果没有新的 object（对象）被定义（就象上面那行 "w1 = w2" 代码中），没有 constructor（构造函数）能 被调用，所以它就是一个 assignment（赋值）。

copy constructor（拷贝构造函数）是一个特别重要的函数，因为它定义一个 object（对象） 如何 passed by value（通过传值的方式被传递）。例如，考虑这个：

bool hasAcceptableQuality(Widget w);

...

Widget aWidget;

if (hasAcceptableQuality(aWidget)) ...

参数 w 通过传值的方式被传递给 hasAcceptableQuality，所以在上面的调用中，aWidget 被 拷贝给 w。拷贝动作通过 Widget 的 copy constructor（拷贝构造函数）被执行。pass-by- value（通过传值方式传递）意味着 "call the copy constructor"（调用拷贝构造函数）。（然 而，通过传值方式传递 user-defined types（用户定义类型）通常是一个不好的想法，pass- by-reference-to-const（传引用给 const）通常是更好的选择。关于细节，参见 Item 20。）

STL 是 Standard Template Library（标准模板库），作为 C++ 标准库的一部分，致力于 containers（容器）（例如，vector，list，set，map，等等），iterators（迭代器）（例如， vector<int>::iterator，set<string>::iterator，等等），algorithms（算法）（例如，for_each， find，sort，等等），以及相关机能。相关机能中的很多都通过 function objects（函数对象） ——行为表现类似于函数的 objects（对象）——提供。这样的 objects（对象）来自于重载了 operator() ——函数调用运算符——的 class（类），如果你不熟悉 STL，在读本书的时候， 你应该有一本像样的参考手册备查，因为对于我来说 STL 太有用了，以至于不能不利用它。 一但你用了一点点，你也会有同样的感觉。

从Java 或 C# 那样的语言来到 C++ 的程序员可能会对 undefined behavior（未定义行为）的 概念感到吃惊。因为各种各样的原因，C++ 中的一些 constructs（结构成分）的行为没有确 切的定义：你不能可靠地预知运行时会发生什么。这里是两个带有 undefined behavior（未定 义行为）的代码的例子：

Terminology（术语）

14

Effective C++

int *p = 0; // p is a null pointer

std::cout << *p; // dereferencing a null pointer

// yields undefined behavior

char name[] = "Darla"; // name is an array of size 6 (don't

// forget the trailing null!)

char c = name[10]; // referring to an invalid array index

// yields undefined behavior

为了强调 undefined behavior（未定义行为）的结果是不可预言而且可能是令人讨厌的，有经 验的 C++ 程序员常常说带有 undefined behavior（未定义行为）的程序 can（能）毁掉你的 辛苦工作的成果。这是真的：一个带有 undefined behavior（未定义行为）的程序 could（可 以）毁掉你的心血。只不过可能性不太大。更可能的是那个程序的表现反复无常，有时会运 行正常，有时会彻底完蛋，还有时会产生错误的结果。有实力的 C++ 程序员能以最佳状态避 开 undefined behavior（未定义行为）。本书中，我会指出许多你必须要注意它的地方。

另一个可能把从其它语言转到 C++ 的程序员搞糊涂的术语是 interface（接口）。Java 和

.NET 的语言都将 Interfaces（接口）作为一种语言要素，但是在 C++ 中没有这种事，但是在 Item 31 讨论了如何模拟它。当我使用术语 "interface"（接口）时，一般情况下我说的是一个 函数的 signature（识别特征），是一个 class（类）的可访问元素（例如，一个 class（类）

的"public interface"，"protected interface"，或 "private interface"），或者是对一个 template（模板）的 type parameter（类型参数）来说必须合法的 expressions（表达式） （参见 Item 41）。也就是说，我是作为一个相当普遍的设计概念来谈论 interface（接口） 的。

client（客户）是使用你写的代码（一般是 interfaces（接口））的某人或某物。例如，一个 函数的 clients（客户）就是它的使用者：调用这个函数（或持有它的地址）的代码的片段以 及写出和维护这样的代码的人。class（类）或者 template（模板）的 clients（客户）是使用 这个 class（类）或 template（模板）的软件的部件，以及写出和维护那些代码的程序员。在 讨论 clients（客户）的时候，我一般指向程序员，因为程序员会被困扰和误导，或者因为不 好的 interfaces（接口）而烦恼。但他们写的代码却不会。

你也许不习惯于为 clients（客户）着想，但是我会用大量的时间试图说服你：你应该尽你所 能使他们的生活更轻松。记住，你也是一个其他人开发的软件的 client（客户）。难道你不希 望那些人为你把事情弄得轻松些吗？除此之外，你几乎肯定会在某个时候发现你自己处在了 你自己的 client（客户）的位置上（也就是说，使用你写的代码），而这个时候，你会为你在 开发你的 interfaces（接口）时在头脑中保持了对 client（客户）的关心而感到高兴。

在本书中，我常常掩盖 functions（函数）和 function templates（函数模板）之间以及 classes（类）和 class templates（类模板）之间的区别。那是因为对其中一个确定的事对另 一个常常也可以确定。如果不是这样，我会区别对待 classes（类），functions（函数），以 及由 classes（类）和 functions（函数）产生的 templates（模板）。

Terminology（术语）

15

Effective C++

在代码注释中提到 constructor（构造函数）和 destructors（析构函数）时，我有时使用缩写 形式 ctor 和 dtor。

Naming Conventions（命名惯例）

我试图为 objects（对象），classes（类），functions（函数），templates（模板）等选择 意味深长的名字，但是在我的某些名字后面的含义可能不会立即显现出来。例如，我特别喜 欢的两个 parameter names（参数名字）是 lhs 和 rhs。它们分别代表 "left-hand side" 和 "right-hand side"。我经常用它们作为实现 binary operators（二元运算符）的函数（例如， operator== 和 operator*）的 parameter names（参数名字）。例如，如果 a 和 b 是代表有理 数的 objects（对象），而且如果 Rational objects（对象）能通过一个 non-member（非成 员）的 operator* 函数相乘（Item 24 中解释的很可能就是这种情况），表达式

a * b

与函数调用

operator*(a,b)

就是等价的。

在Item 24 中，我这样声明 operator*：

const Rational operator*(const Rational& lhs, const Rational& rhs);

你可以看到，left-hand operand（左手操作数）a 在函数内部以 lhs 的面目出现，而 right- hand operand（右手操作数）b 以 rhs 的面目出现。

对于 member functions（成员函数），left-hand argument（左手参数）表现为 this

pointer（this 指针），所以有时候我单独使用 parameter name（参数名字） rhs。你可能已 经在第 5 页中某些 Widget 的 member functions（成员函数）的 declarations（声明）（本文 介绍 copy constructor（拷贝构造函数）的那一段中的例子——译者注）中注意到了这一点。 这一点提醒了我。我经常在示例中使用 Widget class（类）。"Widget" 并不意味着什么东 西。它仅仅是在我需要一个示例类的名字的时候不时地使用一下的名字。它和 GUI 工具包中

的widgets 没有任何关系。

我经常遵循这个规则为 pointers（指针）命名：一个指向 type（类型）T 的 object（对象）的 pointer（指针）被称为 pt，"pointer to T"。以下是例子：

Terminology（术语）

16

Effective C++

Widget *pw; // pw = ptr to Widget

class Airplane;

Airplane *pa; // pa = ptr to Airplane

class GameCharacter;

GameCharacter *pgc; // pgc = ptr to GameCharacter

我对 references（引用）使用类似的惯例：rw 可以认为是一个 reference to a

Widget（引向一个 Widget 的引用），而 ra 是一个 reference to an Airplane（引向一个 Airplane 的引用）。

在讨论 member functions（成员函数）的时候我偶尔会使用名字 mf。

Threading Considerations（对线程的考虑）

作为一种语言，C++ 没有 threads（线程）的概念——实际上，是没有任何一种 concurrency（并发）的概念。对于 C++ 标准库也是同样如此。就 C++ 涉及的范围而言， multithreaded programs（多线程编程）并不存在。

而且至今它们依然如此。我致力于让此书基于标准的，可移植的 C++，但我也不能对 thread safety（线程安全）已成为很多程序员所面临的一个问题的事实视而不见。我对付这个标准 C++ 和现实之间的裂痕的方法就是指出某个 C++ constructs（结构成分）以我的分析很可能

在threaded environment（线程环境）中引起问题的地方。这样不但不会使本书成为一本 multithreaded programming with C++（用 C++ 进行多线程编程）的书。反而，它更会使本书 在相当程度上成为这样一本 C++ 编程的书：将自己在很大程度上限制于 single-threaded（单 线程）思路，承认 multithreading（多线程）的存在，并试图指出有线程意识的程序员需要特 别留心评估我提供的建议的地方。

如果你不熟悉 multithreading（多线程）或者不必为此担心，你可以忽略我关于线程的讨论。 如果你正在编写一个多线程的应用或库，无论如何，请记住我的评注和并将它作为你使用 C++ 时需要致力去解决的问题的起点。

TR1 和 Boost

你会发现提及 TR1 和 Boost 的地方遍及全书。它们每一个都有一个专门的 Item 在某些细节 上进行描述（Item 54 是 TR1，Item 55 是 Boost），但是，不幸的是，这些 Item 在全书的最 后。（他们在那里是因为那样更好一些，我确实试过很多其它的地方。）如果你愿意，你现 在就可以翻开并阅读那些 Item，但是如果你更喜欢从本书的起始处而不是结尾处开始，以下 摘要会对你有所帮助：

TR1 ("Technical Report 1") 是被加入 C++ 标准库的新机能的 specification（规格说明 书）。这些机能以新的 class（类）和 function templates（函数模板）的形式提供了诸

如hash tables（哈希表），reference-counting smart pointers（引用计数智能指针），

Terminology（术语）

17

Effective C++

regular expressions（正则表达式），等等。所有的 TR1 组件都位于嵌套在 namespace std 内部的 namespace tr1 内。

Boost 是一个组织和一个网站 (http://boost.org) 提供的可移植的，经过同行评审的，开源

的C++ 库。大多数 TR1 机能都基于 Boost 的工作，而且直到编译器厂商在他们的 C++ 库发行版中包含 TR1 之前，Boost 网站很可能会保持开发者寻找 TR1 实现的第一站的地 位。Boost 提供的东西比用于 TR1 的更多，无论如何，在很多情况下，它还是值得去了 解一下的。

Terminology（术语）

18

Effective C++

Item 1: 将 C++ 视为 federation of languages（语

言联合体）

作者：Scott Meyers

译者：fatalerror99 (iTePub's Nirvana)

发布：http://blog.csdn.net/fatalerror99/

最初，C++ 仅仅是在 C 的基础上附加了一些 object-oriented（面向对象）的特性。C++ 最初 的名称—— "C with Classes" 就非常直观地表现了这一点。

作为一个语言的成熟过程，C++ 的成长大胆而充满冒险，它吸收的思想，特性，以至于编程 策略与 C with Classes 越来越不同。exceptions（异常）要求不同的建构功能的途径（参见 Item 29），templates（模板）将设计思想提升到新的高度（参见 Item 41），而 STL 定义了 一条前所未见的通向扩展性的道路。

今天的 C++ 已经成为一个 multiparadigm programming language（多范式的编程语言），一 个囊括了 procedural（过程化），object-oriented（面向对象），functional（函数化）， generic（泛型）以及 metaprogramming（元编程）特性的联合体。这些能力和弹性使 C++ 成为无可匹敌的工具，但也引起了一些混乱。所有的 "proper usage"（惯用法）规则似乎都有 例外。我们该如何认识这样一个语言？

最简单的方法是不要将 C++ 视为一个单一的语言，而是一个亲族的语言的 federation（联合 体）。在每一个特定的 sublanguage（子语言）中，它的特性趋向于直截了当，简单易记。 但你从一个 sublanguage（子语言）转到另外一个，它的规则也许会发生变化。为了感受 C++，你必须将它的主要的 sublanguages（子语言）组织到一起。幸运的是，它只有 4 个：

C ——归根结底，C++ 依然是基于 C 的。blocks（模块），statements（语句）， preprocessor（预处理器），built-in data types（内建数据类型），arrays（数组）， pointers（指针）等等，全都来自于 C。在很多方面。C++ 提出了比相应的 C 版本更高 级的解决问题的方法（例如，参见 Item 2（选择 preprocessor（预处理器））和 13（使

用objects（对象）管理 resources（资源））），但是，当你发现你自己工作在 C++ 的 C 部分时，effective programming（高效编程）的规则表现了 C 的诸多限制范围：没有 templates（模板），没有 exceptions（异常），没有 overloading（重载）等等。

Object-Oriented C++ —— C++ 的这部分就是 C with Classes 涉及到的全部：

classes（类）（包括构造函数和析构函数），encapsulation（封装），inheritance（继 承），polymorphism（多态），virtual functions (dynamic binding)（虚拟函数（动态绑 定））等。C++ 的这一部分直接适用于 object-oriented design（面向对象设计）的经典 规则。

Item 1: 将 C++ 视为 federation of languages（语言联合体）

19

Effective C++

Template C++ ——这是 C++ 的 generic programming（泛型编程）部分，大多数程序员 对此都缺乏经验。template（模板）的考虑已遍及 C++，而且好的编程规则中包含特殊

的template-only（模板专用）条款已不再不同寻常（参见 Item 46 通过调用 template functions（模板函数）简化 type conversions（类型转换））。实际上，templates（模 板）极为强大，它提供了一种全新的 programming paradigm（编程范式）—— template metaprogramming (TMP) （模板元编程）。Item 48 提供了一个 TMP 的概述，但是，除 非你是一个 hard-core template junkie（死心塌地的模板瘾君子），否则你不需在此费 心，TMP 的规则对主流的 C++ 编程少有影响。

STL —— STL 是一个 template library（模板库），但它一个非常特殊的 template

library（模板库）。它将 containers（容器），iterators（迭代器），algorithms（算法）

和function objects（函数对象）非常优雅地整合在一起，但是。templates（模板）和 libraries（库）也可以围绕其它的想法建立起来。STL 有很多独特的处事方法，当你和 STL 一起工作，你需要遵循它的规则。

在头脑中保持这四种 sublanguages（子语言），当你从一种 sublanguage（子语言）转到另 一种时，为了高效编程你需要改变你的策略，不要吃惊你遭遇到的情景。例如，使用 built- in（内建）（也就是说，C-like（类 C 的））类型时，pass-by-value（传值）通常比 pass- by-reference（传引用）更高效，但是当你从 C++ 的 C 部分转到 Object-Oriented C++（面向 对象 C++），user-defined constructors（用户自定义构造函数）和 destructors（析构函数） 意味着，通常情况下，更好的做法是 pass-by-reference-to-const（传引用给 const）。在 Template C++ 中工作时，这一点更加重要，因为，在这种情况下，你甚至不知道你的操作涉 及到的 object（对象）的类型。然而，当你进入 STL，你知道 iterators（迭代器）和 function objects（函数对象）以 C 的 pointers（指针）为原型，对于 STL 中的 iterators（迭代器）和 function objects（函数对象），古老的 C 中的 pass-by-value（传值）规则又重新生效。（关 于选择 parameter-passing（参数传递）方式的全部细节，参见 Item 20。）

C++ 不是使用一套规则的单一语言，而是 federation of four sublanguages（四种子语言的联 合体），每一种都有各自的规则。在头脑中保持这些 sublanguages（子语言），你会发现对 C++ 的理解会容易得多。

Things to Remember

effective C++ programming（高效 C++ 编程）规则的变化，依赖于你使用 C++ 的哪一个

部分。

Item 1: 将 C++ 视为 federation of languages（语言联合体）

20

Effective C++

Item 2: 用 consts, enums 和 inlines 取代

#defines

作者：Scott Meyers

译者：fatalerror99 (iTePub's Nirvana)

发布：http://blog.csdn.net/fatalerror99/

这个 Item 改名为“用 compiler（编译器）取代 preprocessor（预处理器）”也许更好一些，因

为#define 根本就没有被看作是语言本身的一部分。这是它很多问题中的一个。当你像下面这 样做：

#define ASPECT_RATIO 1.653

compiler（编译器）也许根本就没有看见这个符号名 ASPECT_RATIO，在 compiler（编译 器）得到源代码之前，这个名字就已经被 preprocessor（预处理器）消除了。结果，名字 ASPECT_RATIO 可能就没有被加入 symbol table（符号表）。如果在编译的时候，发现一个 constant（常量）使用的错误，你可能会陷入混乱之中，因为错误信息中很可能用 1.653 取代

了ASPECT_RATIO。如果，ASPECT_RATIO 不是你写的，而是在头文件中定义的，你可能 会对 1.653 的出处毫无头绪，你还会为了跟踪它而浪费时间。在 symbolic debugger（符号调 试器）中也会遇到同样的问题，同样是因为这个名字可能并没有被加入 symbol table（符号 表）。

解决方案是用 constant（常量）来取代 macro（宏）：

const double AspectRatio = 1.653; // uppercase names are usually for // macros, hence the name change

作为一个 language constant（语言层面上的常量），AspectRatio 被 compilers（编译器）明 确识别并确实加入 symbol table（符号表）。另外，对于 floating point constant（浮点常量） （比如本例）来说，使用 constant（常量）比使用 #define 能产生更小的代码。这是因为 preprocessor（预处理器）盲目地用 1.653 置换 macro name（宏名字）ASPECT_RATIO， 导致你的 object code（目标代码）中存在多个 1.653 的拷贝，如果使用 constant（常量） AspectRatio，就绝不会产生多于一个的拷贝。

用constant（常量）代替 #defines 时，有两个特殊情况值得提出。首先是关于 constant

pointers（常量指针）的定义。因为 constant definitions（常量定义）通常被放在 header files（头文件）中（这样它们就可以被包含在多个 source files（源文件）中），除了

Item 2: 用 consts, enums 和 inlines 取代 #defines

21

Effective C++

pointer（指针）指向的目标是常量外，pointer（指针）本身被声明为 const 更加重要。例 如，在头文件中定义一个 constant char*-based string（基于 char* 的字符串常量）时，你必 须写两次 const：

const char * const authorName = "Scott Meyers";

对于 const（特别是与 pointers（指针）相结合时）的意义和使用的完整讨论，请参见 Item

3。然而在此值的一提的是，string objects（对象）通常比它的 char*-based（基于 char*）的 祖先更可取，所以，更好的 authorName 的定义方式如下：

const std::string authorName("Scott Meyers");

第二个特殊情况涉及到 class-specific constants（类属（类内部专用的）常量）。为了将一个 constant（常量）的作用范围限制在一个 class（类）内，你必须将它作为一个类的 member（成员），而且为了确保它最多只有一个 constant（常量）拷贝，你还必须把它声明 为一个 static member（静态成员）。

class GamePlayer {
private:
static const int NumTurns = 5;			// constant declaration
int scores[NumTurns];			// use of constant
...
};

你从上面只看到了 NumTurns 的 declaration（声明），而不是 definition（定义）。通常， C++ 要求你为你使用的任何东西都提供一个 definition（定义），但是一个 static（静态）的 integral type（整型族）（例如：integers（整型），chars，bools）的 class-specific constants（类属常量）是一个例外。只要你不去取得它们的 address（地址），你可以只声 明并使用它，而不提供它的 definition（定义）。如果你要取得一个 class constant（类属常 量）的 address（地址），或者你使用的 compiler（编译器）在你没有取得 address（地址） 时也不正确地要求 definition（定义）的话，你可以提供如下这样一个独立的 definition（定 义）：

const int GamePlayer::NumTurns;	//	definition of	NumTurns; see
	//	below for why	no value is given

你应该把它放在一个 implementation file（实现文件）而非 header file（头文件）中。因为 class constants（类属常量）的 initial value（初始值）在声明时已经提供（例如：NumTurns 在定义时被初始化为 5），因此在定义处允许没有 initial value（初始值）。

Item 2: 用 consts, enums 和 inlines 取代 #defines

22

Effective C++

注意，顺便提一下，没有办法使用 #define 来创建一个 class-specific constant（类属常

量），因为 #defines 不考虑 scope（作用范围）。一旦一个 macro（宏）被定义，它将大范 围影响你的代码（除非在后面某处存在 #undefed）。这就意味着，#defines 不仅不能用于 class-specific constants（类属常量），而且不能提供任何形式的 encapsulation（封装）， 也就是说，没有类似 "private"（私有）#define 的东西。当然，const data members（const 数据成员）是能够被封装的，NumTurns 就是如此。

比较老的 compilers（编译器）可能不接受上面的语法，因为它习惯于将一个 static class member（静态类成员）在声明时就获得 initial value（初始值）视为非法。而且，in-class initialization （类内初始化）仅仅对于 integral types（整型族）和 constants（常量）才被允 许。如果上述语法不能使用，你可以将 initial value（初始值）放在定义处：

class CostEstimate {
private:
static const double FudgeFactor;			// declaration of static class
...			// constant; goes in header file
};
const double			// definition of static class
CostEstimate::FudgeFactor = 1.35;			// constant; goes in impl. file

这就是你所要做的全部。仅有的例外是当在类的编译期需要 value of a class constant（一个 类属常量的值）的情况，例如前面在声明 array（数组）GamePlayer::scores 时

（compilers（编译器）必须在编译期知道 array（数组）的 size（大小））。如果 compilers（编译器）（不正确地）禁止这种关于 static integral class constants（静态整型族 类属常量）的 initial values（初始值）的使用方法的 in-class specification（规范），一个可 接受的替代方案被亲切地（并非轻蔑地）昵称为 "the enum hack"。这项技术获得以下事实的 支持：一个 enumerated type（枚举类型）的值可以用在一个需要 ints 的地方。所以 GamePlayer 可以被如下定义：

class GamePlayer {
private:
enum { NumTurns = 5 };			// "the enum hack" - makes
			// NumTurns a symbolic name
					for 5
int scores[NumTurns];			// fine
...
};

the enum hack 有几个值得被人所知的原因。首先，the enum hack 的行为在几个方面上更像 一个 #define 而不是 const，而有时这正是你所需要的。例如：可以合法地取得一个 const 的 address（地址），但不能合法地取得一个 enum 的 address（地址），这正像同样不能合法 地取得一个 #define 的 address（地址）。如果你不希望人们得到你的 integral constants（整 型族常量）的 pointer（指针）或 reference（引用），enum（枚举）就是强制约束这一点的

Item 2: 用 consts, enums 和 inlines 取代 #defines

23

Effective C++

好方法。（关于更多的通过编码的方法强制执行设计约束的方法，参见 Item 18。）同样，使 用好的 compilers（编译器）不会为 integral types（整型族类型）的 const objects（const 对 象）分配多余的内存（除非你创建了这个对象的指针或引用），即使拖泥带水的 compilers（编译器）乐意，你也决不会乐意为这样的 objects（对象）分配多余的内存。像 #defines 和 enums（枚举）就绝不会导致这种 unnecessary memory allocation（不必要的内 存分配）。

需要知道 the enum hack 的第二个理由是纯粹实用主义的，大量的代码在使用它，所以当你 看到它时，你要认识它。实际上，the enum hack 是 template metaprogramming（模板元编 程）的一项基本技术（参见 Item 48）。

回到 preprocessor（预处理器）上来，#define 指令的另一个普遍的（不好的）用法是实现看 来像函数，但不会引起一个函数调用的开销的 macros（宏）。以下是一个用较大的宏参数调 用函数 f 的 macro（宏）：

// call f with the maximum of a and b

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

这样的 macro（宏）有数不清的缺点，想起来就让人头疼。

无论何时，你写这样一个 macro（宏），都必须记住为 macro body（宏体）中所有的 arguments（参数）加上括号。否则，当其他人在表达式中调用了你的 macro（宏），你将陷 入麻烦。但是，即使你确实做到了这一点，你还是会看到意想不到的事情发生：

int a = 5, b = 0;

CALL_WITH_MAX(++a, b); // a is incremented twice

CALL_WITH_MAX(++a, b+10); // a is incremented once

这里，调用 f 之前 a 递增的次数取决于它和什么进行比较！

幸运的是，你并不是必须要和这样不知所云的东西打交道。你可以通过一个 inline

function（内联函数）的 template（模板）来获得 macro（宏）的效率，以及完全可预测的行 为和常规函数的类型安全（参见 Item 30）：

template<typename T>	// because we don't
inline void callWithMax(const T& a, const T& b)	// know what T is, we
{	// pass by reference-to-
f(a > b ? a : b);	// const - see Item 20
}

Item 2: 用 consts, enums 和 inlines 取代 #defines

24

Effective C++

这个 template（模板）产生一组函数，每一个获得两个相同类型的对象并使用其中较大的一 个调用 f。这样就不需要为函数体内部的参数加上括号，也不需要担心多余的参数解析次数， 等等。此外，因为 callWithMax 是一个真正的函数，它遵循函数的作用范围和访问规则。例 如，谈论一个类的私有的 inline function（内联函数）会获得正确的理解，但是用 macro（宏）就无法做到这一点。

为了得到 consts，enums 和 inlines 的可用性，你需要尽量减少 preprocessor（预处理器） （特别是 #define）的使用，但还不能完全消除。#include 依然是基本要素，而 #ifdef/#ifndef 也继续扮演着重要的角色。现在还不是让 preprocessor（预处理器）完全退休的时间，但你 应该给它漫长而频繁的假期。

Things to Remember

对于 simple constants（简单常量），用 const objects（const 对象）或 enums（枚举） 取代 #defines。

对于 function-like macros（类似函数的宏），用 inline functions（内联函数）取代 #defines。

Item 2: 用 consts, enums 和 inlines 取代 #defines

25

Effective C++

Item 3: 只要可能就用 const

作者：Scott Meyers

译者：fatalerror99 (iTePub's Nirvana)

发布：http://blog.csdn.net/fatalerror99/

关于 const 的一件美妙的事情是它允许你指定一种 semantic（语义上的）约束：一个特定的 object（对象）不应该被修改。而 compilers（编译器）将执行这一约束。它允许你通知 compilers（编译器）和其他程序员，某个值应该保持不变。如果确实如此，你就应该明确地 表示出来，因为这样一来，你就可以谋求 compilers（编译器）的帮助，确保这个值不会被改 变。

keyword（关键字）const 非常多才多艺。在 classes（类）的外部，你可以将它用于

global（全局）或 namespace（命名空间）范围的 constants（常量）（参见 Item 2），以及 那些在 file（文件）、function（函数）或 block（模块）scope（范围）内被声明为 static（静态）的对象。在 classes（类）的内部，你可以将它用于 static（静态）和 non- static（非静态）data members（数据成员）上。对于 pointers（指针），你可以指定这个 pointer（指针）本身是 const，或者它所指向的数据是 const，或者两者都是，或者都不是：

char greeting[] = "Hello";

char *p = greeting; // non-const pointer, // non-const data

const char *p = greeting; // non-const pointer, // const data

char * const p = greeting; // const pointer, // non-const data

const char * const p = greeting; // const pointer, // const data

这样的语法本身其实并不像表面上那样反复无常。如果 const 出现在星号左边，则指针 pointed to（指向）的内容为 constant（常量）；如果 const 出现在星号右边，则 pointer itself（指针自身）为 constant（常量）；如果 const 出现在星号两边，则两者都为 constant（常量）。

当指针指向的内容为 constant（常量）时，一些人将 const 放在类型之前，另一些人将它放 在类型之后星号之前。两者在意义上并没有区别，所以，如下两个函数具有相同的 parameter type（参数类型）：

Item 3: 只要可能就用 const

26

Effective C++

void f1(const Widget *pw); // f1 takes a pointer to a

//constant Widget object

void f2(Widget const *pw); // so does f2

因为它们都存在于实际的代码中，你应该习惯于这两种形式。

STL iterators（迭代器）以 pointers（指针）为原型，所以一个 iterator 在行为上非常类似于 一个 T* pointer（指针）。声明一个 iterator 为 const 就类似于声明一个 pointer（指针）为 const（也就是说，声明一个 T* const pointer（指针））：不能将这个 iterator 指向另外一件 不同的东西，但是它所指向的东西本身可以变化。如果你要一个 iterator 指向一个不能变化的 东西（也就是一个 const T* pointer（指针）的 STL 对等物），你需要一个 const_iterator：

std::vector<int> vec;
...
const std::vector<int>::iterator iter =			// iter acts like a T* const
vec.begin();
*iter = 10;			// OK, changes what iter points to
++iter;			// error! iter is const
std::vector<int>::const_iterator cIter =			// cIter acts like a const T*
vec.begin();
*cIter = 10;
			// error! *cIter is const
++cIter;			// fine, changes cIter

对const 最强有力的用法来自于它在 function declarations（函数声明）中的应用。在一个 function declaration（函数声明）中，const 既可以用在函数的 return value（返回值）上，也 可以用在个别的 parameters（参数）上，对于 member functions（成员函数），还可以用于 整个函数。

一个函数返回一个 constant value（常量值），常常可以在不放弃安全和效率的前提下尽可能 减少客户的错误造成的影响。例如，考虑在 Item 24 中考察的 rational numbers（有理数）的 operator* 函数的声明。

class Rational { ... };

const Rational operator*(const Rational& lhs, const Rational& rhs);

很多第一次看到这些的程序员会不以为然。为什么 operator* 的结果应该是一个 const object（对象）？因为如果它不是，客户就可以犯下如此暴行：

Rational a, b, c;

...

(a * b) = c; // invoke operator= on the // result of a*b!

我不知道为什么一些程序员要为两个数的乘积赋值，但是我知道很多程序员这样做也并非不 称职。所有这些可能来自一个简单的输入错误（要求这个类型能够隐式转型到 bool）：

Item 3: 只要可能就用 const

27

Effective C++

if (a * b = c) ... // oops, meant to do a comparison!

如果 a 和 b 是 built-in type（内建类型），这样的代码显而易见是非法的。一个好的 user- defined types（用户自定义类型）的特点就是要避免与 built-ins（内建类型）毫无理由的不和 谐（参见 Item 18），而且对我来说允许给两个数的乘积赋值看上去正是毫无理由的。将 operator* 的返回值声明为 const 就可以避免这一点，这就是我们要这样做的理由。

关于 const parameters（参数）没什么特别新鲜之处——它们的行为就像 local（局部）的 const objects（对象），而且无论何时，只要你能，你就应该这样使用。除非你需要改变一个 parameter（参数）或 local object（本地对象）的能力，否则，确保将它声明为 const。它只 需要你键入六个字符，就能将你从我们刚刚看到的这个恼人的错误中拯救出来：“我想键入 '=='，但我意外地键入了 '='”。

const member functions（const 成员函数）

member functions（成员函数）被声明为 const 的目的是标明这个 member functions（成员 函数）可能会被 const objects（对象）调用。因为两个原因，这样的 member functions（成 员函数）非常重要。首先，它使一个 class（类）的 interface（接口）更容易被理解。知道哪 个函数可以改变 object（对象）而哪个不可以是很重要的。第二，它们可以和 const objects（对象）一起工作。因为，书写高效代码有一个很重要的方面，就像 Item 20 所解释 的，提升一个 C++ 程序的性能的基本方法就是 pass objects by reference-to-const（以传引 用给 const 的方式传递一个对象）。这个技术只有在 const member functions（成员函数）和 作为操作结果的 const-qualified objects（被 const 修饰的对象）存在时才是可行的。

很多人没有注意到这样的事实，即 member functions（成员函数）在只有 constness（常量 性）不同时是可以被 overloaded（重载）的，但这是 C++ 的一个重要特性。考虑一个代表文 本块的类：

class TextBlock {
public:
...
const char& operator[](std::size_t position) const					// operator[] for
{ return text[position]; }					// const objects
char& operator[](std::size_t position)					// operator[] for
{ return text[position]; }					// non-const objects
private:
std::string text;
};

TextBlock 的 operator[]s 可能会这样使用：

	TextBlock tb("Hello");
	std::cout << tb[0];	// calls non-const
	const TextBlock ctb("World");	// TextBlock::operator[]
		// calls const TextBlock::operator[]
	std::cout << ctb[0];

Item 3: 只要可能就用 const

28

Effective C++

顺便提一下，const objects（对象）在实际程序中最经常出现的是作为这样一个操作的结果： passed by pointer- or reference-to-const（以传指针或者引用给 const 的方式传递）。上面的 ctb 的例子是人工假造的。下面这个例子更真实一些：

void print(const TextBlock& ctb)			// in this function, ctb is const
{
	std::cout << ctb[0];		// calls const TextBlock::operator[]
...
}

通过 overloading（重载） operator[]，而且给不同的版本不同的返回类型，你能对 const 和 non-const 的 TextBlocks 做不同的操作：

std::cout << tb[0];	// fine — reading a
	// non-const TextBlock
tb[0] = 'x';	// fine — writing a
	// non-const TextBlock
std::cout << ctb[0];	// fine — reading a
	// const TextBlock
ctb[0] = 'x';	// error! — writing a
	// const TextBlock

请注意这里的错误只与被调用的 operator[] 的 return type（返回类型）有关，而调用 operator[] 本身总是正确的。错误出现在企图为 const char& 赋值的时候，因为它是 const 版 本的 operator[] 的 return type（返回类型）。

再请注意 non-const 版本的 operator[] 的 return type（返回类型）是 reference to a char（一

个char 的引用）而不是一个 char 本身。如果 operator[] 只是返回一个简单的 char，下面的 语句将无法编译：

tb[0] = 'x';

因为改变一个返回 built-in type（内建类型）的函数的返回值总是非法的。即使它合法，C++ returns objects by value（以传值方式返回对象）这一事实（参见 Item 20）也意味着被改变 的是 tb.text[0] 的一个 copy（拷贝），而不是 tb.text[0] 自己，这不会是你想要的行为。

让我们为哲学留一点时间。看看一个 member function（成员函数）是 const 意味着什么？有 两个主要的概念：bitwise constness（二进制位常量性）（也称为 physical constness（物理 常量性））和 logical constness（逻辑常量性）。

bitwise（二进制位）const 派别坚持认为，一个 member function（成员函数），当且仅当它 不改变 object（对象）的任何 data members（数据成员）（static（静态的）除外），也就 是说如果不改变 object（对象）内的任何 bits（二进制位），则这个 member function（成员 函数）就是 const。bitwise constness（二进制位常量性）的一个好处是比较容易监测违例： 编译器只需要寻找对 data members（数据成员）的 assignments（赋值）。实际上，bitwise

Item 3: 只要可能就用 const

29

Effective C++

constness（二进制位常量性）就是 C++ 对 constness（常量性）的定义，一个 const member function（成员函数）不被允许改变调用它的 object（对象）的任何 non-static data members（非静态数据成员）。

不幸的是，很多效果上并不是完全 const 的 member functions（成员函数）通过了 bitwise（二进制位）的检验。特别是，一个经常改变某个 pointer（指针）指向的内容的 member function（成员函数）效果上不是 const 的。除非这个 pointer（指针）在这个 object（对象）中，否则这个函数就是 bitwise（二进制位）const 的，编译器也不会提出异 议。例如，假设我们有一个 TextBlock-like class（类似 TextBlock 的类），因为它需要与一个 不知 string objects（对象）为何物的 C API 打交道，所以它需要将它的数据存储为 char* 而 不是 string。

class CTextBlock { public:

...
char& operator[](std::size_t position) const				// inappropriate (but bitwise
{ return pText[position]; }				// const) declaration of
private:				// operator[]
char		*pText;
};

尽管 operator[] 返回 a reference to the object's internal data（一个引向对象内部数据的引 用），这个 class（类）还是（不适当地）将它声明为一个 const member function（成员函 数）（Item 28 将谈论一个深入的主题）。先将它放到一边，看看 operator[] 的实现，它并没 有使用任何手段改变 pText。结果，编译器愉快地生成了 operator[] 的代码，因为毕竟对所有 编译器而言，它都是 bitwise（二进制位）const 的，但是我们看看会发生什么：

const CTextBlock cctb("Hello");	// declare constant object
char *pc = &cctb[0];	// call the const operator[] to get a
	// pointer to cctb's data
*pc = 'J';	// cctb now has the value "Jello"

这里确实出了问题，你用一个 particular value（确定值）创建一个 constant object（常量对 象），然后你只是用它调用了 const member functions（成员函数），但是你还是改变了它的 值！

这就引出了 logical constness（逻辑常量性）的概念。这一理论的信徒认为：一个 const member function（成员函数）可能会改变调用它的 object（对象）中的一些 bits（二进制 位），但是只能用客户无法察觉的方法。例如，你的 CTextBlock class（类）在需要的时候可 以储存文本块的长度：

Item 3: 只要可能就用 const

30

Effective C++

class CTextBlock { public:

...

std::size_t length() const;

private:

char

*pText;

std::size_t

textLength;

// last calculated length of textblock

bool lengthIsValid;

// whether length is currently valid

};

std::size_t CTextBlock::length() const

{

if (!lengthIsValid) {

textLength = std::strlen(pText);

// error! can't assign to textLength

lengthIsValid = true;

// and lengthIsValid in a const

}

// member function

return textLength;

}

length 的实现当然不是 bitwise（二进制位）const 的—— textLength 和 lengthIsValid 都可能 会被改变——但是它还是被看作对 const CTextBlock 对象有效。但编译器不同意，它还是坚

持bitwise constness（二进制位常量性），怎么办呢？

解决方法很简单：利用以 mutable 闻名的 C++ 的 const-related（const 相关）的灵活空间。 mutable 将 non-static data members（非静态数据成员）从 bitwise constness（二进制位常

量性）的约束中解放出来：

class CTextBlock { public:

...

std::size_t length() const;

private:

char

*pText;

mutable std::size_t textLength;

// these data members may

mutable bool lengthIsValid;

// always be modified, even in

};

// const member functions

std::size_t CTextBlock::length() const

{

if (!lengthIsValid) {

textLength = std::strlen(pText);

// now fine

}

lengthIsValid = true;

// also fine

return textLength;

}

避免 const 和 non-const member functions（成员函数）的重复

mutable 对于解决 bitwise-constness-is-not-what-I-had-in-mind（二进制位常量性不太合我的 心意）的问题是一个不错的解决方案，但它不能解决全部的 const-related（const 相关）难 题。例如，假设 TextBlock（包括 CTextBlock）中的 operator[] 不仅要返回一个适当的字符的

Item 3: 只要可能就用 const

31

Effective C++

reference（引用），它还要进行 bounds checking（边界检查），logged access information（记录访问信息），甚至 data integrity validation（数据完整性确认），将这些功 能都加入到 const 和 non-const 的 operator[] 函数中（不必为我们现在有着非凡长度的 implicitly inline functions（隐含内联函数）而烦恼，参见 Item 30），使它们变成如下这样的 庞然大物：

class TextBlock { public:

...

const char& operator[](std::size_t position) const

{
	...				// do bounds checking
...					// log access data
...					// verify data integrity
}	return text[position];
char& operator[](std::size_t position)
{
	...				// do bounds checking
...					// log access data
...
					// verify data integrity
}	return text[position];
private:
std::string text;
};

哎呀！你是说 code duplication（重复代码）？还有随之而来的额外的编译时间，维护成本以 及代码膨胀等令人头痛之类的事情吗？当然，也可以将 bounds checking（边界检查）等全部 代码转移到一个单独的 member function（成员函数）（自然是 private（私有）的）中，并 让两个版本的 operator[] 来调用它，但是，你还是要重复写出调用那个函数和 return 语句的 代码。

你真正要做的是只实现一次 operator[] 的功能，而使用两次。换句话说，你可以用一个版本的 operator[] 去调用另一个版本。并可以为我们 casting away（通过强制转型脱掉） constness（常量性）。

作为一个通用规则，casting（强制转型）是一个非常坏的主意，我会投入整个一个 Item 的篇 幅来告诉你不要使用它（Item 27），但是 code duplication（重复代码）也不是什么好事。在 当前情况下，const 版本的 operator[] 所做的事也正是 non-const 版本所做的，仅有的不同是 它有一个 const-qualified return type（被 const 修饰的返回类型）。在这种情况下，casting away（通过强制转型脱掉）return value（返回类型）的 const 是安全的，因为，无论谁调用 non-const operator[]，首先要有一个 non-const object（对象）。否则，它不能调用一个 non- const 函数。所以，即使需要一个 cast（强制转型），让 non-const operator[] 调用 const 版 本也是避免重复代码的安全方法。代码如下，你读了后面的解释后对它的理解可能会更加清 晰：

Item 3: 只要可能就用 const

32

Effective C++

class TextBlock { public:

...
const char& operator[](std::size_t position) const				// same as before
{
	...
...
...

return text[position];

}
char& operator[](std::size_t position)				// now just calls const op[]
{
	return
	const		_cast<char&>(	// cast away const on
				// op[]'s return type;
	static_cast<const TextBlock&>(*this)			// add const to *this's		type;
);		[position]		// call const version of op[]
}
...
};

正如你看到的，代码中有两处 casts（强制转型），而不是一处。我们让 non-const operator[] 调用 const 版本，但是，如果在 non-const operator[] 的内部，我们仅仅是调用 operator[]， 那我们将递归调用我们自己。它会进行一百万次甚至更多。为了避免 infinite recursion（无限 递归），我们必须明确指出我们要调用 const operator[]，但是没有直接的办法能做到这一 点，于是我们将 this 从 TextBlock& 的自然类型强制转型到 const TextBlock&。是的，我们使

用cast（强制转型）为它加上了 const！所以我们有两次 casts（强制转型）：第一次是为 this 加上 const（以便在我们调用 operator[] 时调用它的 const 版本），第二次是从 const operator[] 的 return value（返回值）之中去掉 const。

加上 const 的 cast（强制转型）仅仅是强制施加一次安全的转换（从一个 non-const object（对象）到一个 const object（对象）），所以我们用一个 static_cast 来做。去掉 const 只能经由 const_cast 来完成，所以在这里我们没有别的选择。（在技术上，我们有。 一个 C-style cast（C 风格的强制转型）也能工作，但是，就像我在 Item 27 中解释的，这样

的casts（强制转型）很少是一个正确的选择。如果你不熟悉 static_cast 或 const_cast，Item

27 中包含有一个概述。）

在完成其它事情的基础上，我们在此例中调用了一个 operator（操作符），所以，语法看上 去有些奇怪。导致其不会赢得选美比赛，但是它根据 const 版本的 operator[] 实现其 non- const 版本而避免 code duplication（代码重复）的方法达到了预期的效果。使用丑陋的语法 达到目标是否值得最好由你自己决定，但是这种根据 const member function（成员函数）实 现它的 non-const 版本的技术却非常值得掌握。

更加值得掌握的是做这件事的反向方法——通过用 const 版本调用 non-const 版本来避免重复 ——是你不能做的。记住，一个 const member function（成员函数）承诺绝不会改变它的 object（对象）的逻辑状态，但是一个 non-const member function（成员函数）不会做这样

Item 3: 只要可能就用 const

33

Effective C++

的承诺。如果你从一个 const member function（成员函数）调用一个 non-const member function（成员函数），你将面临你承诺不会变化的 object（对象）被改变的风险。这就是为 什么使用一个 const member function（成员函数）调用一个 non-const member function（成 员函数）是错误的，object（对象）可能会被改变。实际上，那样的代码如果想通过编译，你 必须用一个 const_cast 来去掉 this 的 const，这是一个显而易见的麻烦。而反向的调用—— 就像我在上面用的——是安全的：一个 non-const member function（成员函数）对一个 object（对象）能够为所欲为，所以调用一个 const member function（成员函数）也没有任 何风险。这就是为什么 static_cast 在这种情况下可以工作在 this 上的原因：这里没有 const- related 危险。

就像在本 Item 开始我所说的，const 是一件美妙的东西。在 pointers（指针）和 iterators（迭 代器）上，在 pointers（指针），iterators（迭代器）和 references（引用）涉及到的 object（对象）上，在 function parameters（函数参数）和 return types（返回值）上，在 local variables（局部变量）上，在 member functions（成员函数）上，const 是一个强有力 的盟友。只要可能就用它，你会为你所做的感到高兴。

Things to Remember

将某些东西声明为 const 有助于编译器发现使用错误。const 能被用于任何 scope（范 围）中的 object（对象），用于 function parameters（函数参数）和 return types（返回 类型），用于整个 member functions（成员函数）。

编译器坚持 bitwise constness（二进制位常量性），但是你应该用 conceptual constness（概念上的常量性）来编程。（此处原文有误，conceptual constness为作者 在本书第二版中对 logical constness 的称呼，正文中的称呼改了，此处却没有改。其实 此处还是作者新加的部分，却使用了旧的术语，怪！——译者注）

当 const 和 non-const member functions（成员函数）具有本质上相同的实现的时候，使

用non-const 版本调用 const 版本可以避免 code duplication（代码重复）。

Item 3: 只要可能就用 const

34

Effective C++

Item 4: 确保 objects（对象）在使用前被初始化

作者：Scott Meyers

译者：fatalerror99 (iTePub's Nirvana)

发布：http://blog.csdn.net/fatalerror99/

C++ 看上去在对象的值的初始化方面变化莫测。例如，如果你这样做，

int x;

在某些情形下，x 会被初始化（为 0），但是在其它情形下，也可能没有。如果你这样做，

class Point {

int x, y; };

...

Point p;

p 的 data members（数据成员）有时会被初始化（为 0），但有时没有。如果你从一个不存

在uninitialized objects（未初始化对象）的语言来到 C++，请注意这个问题，因为它非常重 要。

读取一个 uninitialized values（未初始化值）会引起 undefined behavior（未定义行为）。在 一些平台上，读一个 uninitialized value（未初始化值）会引起程序中止，更可能的情况是得 到一个你所读的那个位置上的 semi-random bits（半随机二进制位），最终导致不可预测的 程序行为和恼人的调试。

现在，有一些描述关于什么时候能保证 object initialization（对象初始化）会发生什么时候不 能保证的规则。不幸的是，这些规则很复杂——我觉得它复杂得无法记住。通常，如果你使

用C++ 的 C 部分（参见 Item 1），而且 initialization（初始化）可能会花费一些运行时间， 它就不能保证发生。如果你使用 C++ 的 non-C 部分，事情会有些变化。这就是为什么一个 array（数组）（来自 C++ 的 C 部分）不能确保它的元素被初始化，但是一个 vector（来自 C++ 的 STL 部分）就能够确保。

处理这种事情的表面不确定状态的最好方法就是总是在使用之前初始化你的对象。对于 built- in types（内建类型）的 non-member objects（非成员对象），需要你手动做这件事。例如：

Item 4: 确保 objects（对象）在使用前被初始化

35

Effective C++

int x = 0;	// manual initialization of an int
const char * text = "A C-style string";	// manual initialization of a
	// pointer (see also Item 3)
double d;	// "initialization" by reading from
std::cin >> d;	// an input stream

除此之外的几乎全部情况，initialization（初始化）的重任就落到了 constructors（构造函数） 的身上。这里的规则很简单：确保 all constructors（所有的构造函数）都初始化了 object（对象）中的每一样东西。

这个规则很容易遵守，但重要的是不要把 assignment（赋值）和 initialization（初始化）搞 混。考虑下面这个表现一个通讯录条目的 class（类）的 constructor（构造函数）：

class PhoneNumber { ... };

class ABEntry {

// ABEntry = "Address Book Entry"

public:

ABEntry(const std::string& name, const std::string& address, const std::list<PhoneNumber>& phones);

private:

std::string theName;

std::string theAddress;

std::list<PhoneNumber> thePhones;

int num TimesConsulted;

};

ABEntry::ABEntry(const std::string& name, const std::string& address, const std::list<PhoneNumber>& phones)

{

theName = name;		// these are all assignments,
theAddress = address;		// not initializations
thePhones = phones;
numTimesConsulted = 0;

}

这样做虽然使得 ABEntry objects（对象）具有了你所期待的值，但还不是最好的做法。C++ 的规则规定一个 object（对象）的 data members（数据成员）在进入 constructor（构造函 数）的函数体之前被初始化。在 ABEntry 的 constructor（构造函数）内，theName， theAddress 和 thePhones 不是 being initialized（被初始化），而是 being assigned（被赋 值）。initialization（初始化）发生得更早——在进入 ABEntry 的 constructor（构造函数）的

Item 4: 确保 objects（对象）在使用前被初始化

36

Effective C++

函数体之前，它们的 default constructors（缺省的构造函数）已经被自动调用。但不包括 numTimesConsulted，因为它是一个 built-in type（内建类型）。不能保证它在被赋值之前被

初始化。

一个更好的写 ABEntry constructor（构造函数）的方法是用 member initialization list（成员 初始化列表）来代替 assignments（赋值）：

ABEntry::ABEntry(const std::string& name, const std::string& address, const std::list<PhoneNumber>& phones)

: theName(name),
theAddress(address),			// these are now all initializations
thePhones(phones),
numTimesConsulted(0)
{}			// the ctor body is now empty

这个 constructor（构造函数）的最终结果和前面那个相同，但是通常它有更高的效率。 assignment-based（基于赋值）的版本会首先调用 default constructors（缺省构造函数）初 始化 theName，theAddress 和 thePhones，然而很快又在 default-constructed（缺省构造） 的值之上赋予新值。那些 default constructions（缺省构造函数）所做的工作被浪费了。而 member initialization list（成员初始化列表）的方法避免了这个问题，因为 initialization list（初始化列表）中的 arguments（参数）就可以作为各种 data members（数据成员）的 constructor（构造函数）所使用的 arguments（参数）。在这种情况下，theName 从 name

中copy-constructed（拷贝构造），theAddress 从 address 中 copy-constructed（拷贝构

造），thePhones 从 phones 中 copy-constructed（拷贝构造）。对于大多数类型来说，只调 用一次 copy constructor（拷贝构造函数）的效率比先调用一次 default constructor（缺省构 造函数）再调用一次 copy assignment operator（拷贝赋值运算符）的效率要高（有时会高很 多）。

对于 numTimesConsulted 这样的 built-in type（内建类型）的 objects（对象）， initialization（初始化）和 assignment（赋值）没有什么不同，但为了统一性，最好是经由 member initialization（成员初始化）来 initialize（初始化）每一件东西。类似地，当你只想 default-construct（缺省构造）一个 data member（数据成员）时也可以使用 member initialization list（成员初始化列表），只是不必指定 initialization argument（初始化参数）而 已。例如，如果 ABEntry 有一个不取得 parameters（参数）的 constructor（构造函数），它 可以像这样实现：

ABEntry::ABEntry()
:theName(),	// call theName's default ctor;
theAddress(),	// do the same for theAddress;
thePhones(),	// and for thePhones;
numTimesConsulted(0)	// but explicitly initialize
{}	// numTimesConsulted to zero

Item 4: 确保 objects（对象）在使用前被初始化

37

Effective C++

因为对于那些在 member initialization list（成员初始化列表）中的，没有 initializers（初始化 器）的，user-defined types（用户自定义类型）的 data members（数据成员），编译器会自 动调用其 default constructors（缺省构造函数），所以一些程序员会认为上面的方法有些过 分。这也不难理解，但是一个方针是：在 initialization list（初始化列表）中总是列出每一个 data member（数据成员），这就可以避免一旦发生疏漏就必须回忆起可能是哪一个 data members（数据成员）没有被初始化。例如，因为 numTimesConsulted 是一个 built-in type（内建类型），如果将它从 member initialization list（成员初始化列表）中删除，就为 undefined behavior（未定义行为）打开了方便之门。

有时，即使是 built-in types（内建类型），initialization list（初始化列表）也必须使用。比 如，const 或 references（引用）data members（数据成员）是必须 be initialized（被初始 化）的，它们不能 be assigned（被赋值）（参见 Item 5）。为了避免记忆什么时候 data members（数据成员）必须在 member initialization list（成员初始化列表）中初始化，而什 么时候又是可选的，最简单的方法就是总是使用 initialization list（初始化列表）。它有时是 必须的，而且它通常都比 assignments（赋值）更有效率。

很多 classes（类）有多个 constructors（构造函数），而每一个 constructor（构造函数）都 有自己的 member initialization list（成员初始化列表）。如果有很多 data members（数据成 员）和/或 base classes（基类），成倍增加的 initialization lists（初始化列表）的存在引起令 人郁闷的重复（在列表中）和厌烦（在程序员中）。在这种情况下，不能不讲道理地从列表 中删除那些 assignment（赋值）和 true initialization（真正的初始化）一样工作的 data members（数据成员）项目，而是将 assignments（赋值）移到一个单独的（当然是 private（私有）的）函数中，以供所有 constructors（构造函数）调用。这个方法对于那些 true initial values（真正的初始值）是从文件中读入或从数据库中检索出来的 data members（数据成员）特别有帮助。然而，通常情况下，true member initialization（真正的 成员初始化）（经由一个 initialization list（初始化列表））比经由 assignment（赋值）来进 行的 pseudo-initialization（假初始化）更可取。

C++ 并非变幻莫测的方面是一个 object（对象）的数据被初始化的顺序。这个顺序总是相同 的：base classes（基类）在 derived classes（派生类）之前被初始化（参见 Item 12），在 一个 class（类）内部，data members（数据成员）按照它们被声明的顺序被初始化。例 如，在 ABEntry 中，theName 总是首先被初始化，theAddress 是第二个，thePhones 第 三，numTimesConsulted 最后。即使它们在 member initialization list（成员初始化列表）中 以一种不同的顺序排列（这不幸合法），这依然是成立的。为了避免读者混淆，以及一些模 糊不清的行为引起错误的可能性，initialization list（初始化列表）中的 members（成员）的 排列顺序应该总是与它们在 class（类）中被声明的顺序保持一致。

一旦处理了 built-in types（内建类型）的 non-member objects（非成员对象）的显式初始 化，而且确保你的 constructors（构造函数）使用 member initialization list（成员初始化列 表）初始化了它的 base classes（基类）和 data members（数据成员），那就只剩下一件事 情需要费心了。那就是——深呼吸先——定义在不同 translation units（转换单元）中的 non- local static objects（非局部静态对象）的 initialization（初始化）的顺序。

Item 4: 确保 objects（对象）在使用前被初始化

38

Effective C++

让我们一片一片地把这个词组拆开。

一个 static object（静态对象）的生存期是从它创建开始直到程序结束。stack and heap- based objects（基于堆栈的对象）就被排除在外了。包括 global objects（全局对象）， objects defined at namespace scope（定义在命名空间范围内的对象），objects declared static inside classes（在类内部声明为静态的对象），objects declared static inside functions（在函数内部声明为静态的对象）和 objects declared static at file scope（在文件范 围内被声明为静态的对象）。static objects inside functions（在函数内部的静态对象）以 local static objects（局部静态对象）（因为它局部于函数）为人所知，其它各种 static objects（静态对象）以 non-local static objects（非局部静态对象）为人所知。程序结束时 static objects（静态对象）会自动销毁，也就是当 main 停止执行时会自动调用它们的 destructors（析构函数）。

一个 translation unit（转换单元）是可以形成一个单独的 object file（目标文件）的 source code（源代码）。基本上是一个单独的 source file（源文件），再加上它全部的 #include 文 件。

我们关心的问题是这样的：包括至少两个分别编译的 source files（源文件），每一个中都至 少包含一个 non-local static object（非局部静态对象）（也就是说，global（全局）的，at namespace scope（命名空间范围）的，static in a class（类内）的或 at file scope（文件范 围）的 object（对象））。实际的问题是这样的：如果其中一个 translation unit（转换单元） 内的一个 non-local static object（非局部静态对象）的 initialization（初始化）用到另一个 translation unit（转换单元）内的non-local static object（非局部静态对象），它所用到的 object（对象）可能没有被初始化，因为 the relative order of initialization of non-local static objects defined in different translation units is undefined（定义在不同转换单元内的非局部静 态对象的初始化的相对顺序是没有定义的）。

一个例子可以帮助我们。假设你有一个 FileSystem class（类），可以使 Internet 上的文件看 起来就像在本地。因为你的 class（类）使得世界看起来好像只有一个单独的 file system（文 件系统），你可以在 global（全局）或 namespace（命名空间）范围内创建一个专门的 object（对象）来代表这个单独的 file system（文件系统）：

class FileSystem {				// from your library
public:
...
std::size_t numDisks() const;				// one of many member functions
...
};
extern FileSystem tfs;				// object for clients to use;
				// "tfs" = "the file system"

一个 FileSystem object（对象）绝对是举足轻重的，所以在 theFileSystem object（对象）被 创建之前就使用将会损失惨重。

Item 4: 确保 objects（对象）在使用前被初始化

39

Effective C++

现在假设一些客户为一个 file system（文件系统）中的目录创建了一个 class（类），他们的 class（类）使用了 theFileSystem object（对象）：

class Directory {

// created by library client

public:

Directory( params );

...

};

Directory::Directory( params )

{

...

std::size_t disks = tfs.numDisks(); // use the tfs object

...

}

更进一步，假设这个客户决定为临时文件创建一个单独的 Directory object（对象）：

Directory tempDir( params ); // directory for temporary files

现在 initialization order（初始化顺序）的重要性变得明显了：除非 tfs 在 tempDir 之前初始 化，否则，tempDir 的 constructor（构造函数）就会在 tfs 被初始化之前试图使用它。但是， tfs 和 tempDir 是被不同的人于不同的时间在不同的 source files（源文件）中创建的——它们 是定义在不同 translation units（转换单元）中的 non-local static objects（非局部静态对

象）。你怎么能确保 tfs 一定会在 tempDir 之前被初始化呢？

你不能。重申一遍，the relative order of initialization of non-local static objects defined in different translation units is undefined（定义在不同转换单元内的非局部静态对象的初始化的 相对顺序是没有定义的）。这是有原因的。决定 non-local static objects（非局部静态对象） 的“恰当的”初始化顺序是困难的，非常困难，以至于无法完成。在最常见的形式下——多个 translation units（转换单元）和 non-local static objects（非局部静态对象）通过 implicit template instantiations（隐式模板实例化）产生（这本身可能也是经由 implicit template instantiations（隐式模板实例化）引起的）——不仅不可能确定一个正确的 initialization（初 始化）顺序，甚至不值得去寻找可能确定正确顺序的特殊情况。

幸运的是，一个小小的设计改变从根本上解决了这个问题。全部要做的就是将每一个 non- local static object（非局部静态对象）移到它自己的函数中，在那里它被声明为 static（静 态）。这些函数返回它所包含的 objects（对象）的引用。客户可以调用这些函数来代替直接 涉及那些 objects（对象）。换一种说法，就是用 local static objects（局部静态对象）取代 non-local static objects（非局部静态对象）。（aficionados of design patterns（设计模式迷 们）会认出这是 Singleton 模式的通用实现）。

这个方法建立在 C++ 保证 local static objects（局部静态对象）的初始化发生在因为调用那个 函数而第一次遇到那个 object（对象）的 definition（定义）时候。所以，如果你用调用返回 references to local static objects（局部静态对象的引用）的函数的方法取代直接访问 non-

Item 4: 确保 objects（对象）在使用前被初始化

40

Effective C++

local static objects（非局部静态对象）的方法，你将确保你取回的 references（引用）引向 initialized objects（已初始化的对象）。作为一份额外收获，如果你从不调用这样一个仿效 non-local static object（非局部静态对象）的函数，你就不会付出创建和销毁这个 object（对 象）的代价，而一个 true non-local static objects（真正的非局部静态对象）则不会有这样的 效果。

以下就是这项技术在 tfs 和 tempDir 上的应用：

class FileSystem { ... };

// as before

FileSystem& tfs()

// this replaces the tfs object; it could be

{

// static in the FileSystem class

static FileSystem fs;

// define and initialize a local

static object

}

return fs;

// return a reference to it

class Directory { ... };

// as before

Directory::Directory( params )

// as before, except references to tfs are

{

// now to tfs()

...

std::size_t disks = tfs().numDisks();

...

}

Directory& tempDir()

// this replaces the tempDir object; it

{

// could be static in the Directory class

static Directory td;

// define/initialize local static object

return td;

// return reference to it

}

这个改良系统的客户依然可以按照他们已经习惯的方法编程，只是他们现在应该用 tfs() 和 tempDir() 来代替 tfs 和 tempDir。也就是说，他们应该使用返回 references to objects（对象 引用）的函数来代替使用 objects themselves（对象自身）。

按照以下步骤来写 reference-returning functions（返回引用的函数）总是很简单：在第 1 行 定义并初始化一个 local static object（局部静态对象），在第 2 行返回它。这样的简单使它 们成为 inlining（内联化）的完美的候选者，特别是在它们被频繁调用的时候（参见 Item

30）。在另一方面，这些函数包含 static object（静态对象）的事实使它们在 multithreaded systems（多线程系统）中会出现问题。更进一步，任何种类的 non-const static object（非常 量静态对象）—— local（局部）的或 non-local（非局部）的——在 multiple threads（多线 程）存在的场合都会发生麻烦。解决这个麻烦的方法之一是在程序的 single-threaded（单线 程）的启动部分手动调用所有的 reference-returning functions（返回引用的函数）。以此来 避免 initialization-related（与初始化相关）的混乱环境。

当然，用 reference-returning functions（返回引用的函数）来防止 initialization order problems（初始化顺序问题）的想法首先依赖于你的 objects（对象）有一个合理的 initialization order（初始化顺序）。如果你有一个系统，其中 object A 必须在 object B 之前 初始化，但是 A 的初始化又依赖于 B 已经被初始化，你将遇到问题，坦白地讲，你遇到大麻 烦了。然而，如果你避开了这种病态的境遇，这里描述的方法会很好地为你服务，至少在 single-threaded applications（单线程应用）中是这样。

Item 4: 确保 objects（对象）在使用前被初始化

41

Effective C++

避免在初始化之前使用 objects（对象），你只需要做三件事。首先，手动初始化 built-in types（内建类型）的 non-member objects（非成员对象）。第二，使用 member initialization lists（成员初始化列表）初始化一个 object（对象）的所有部分。最后，在设计 中绕过搞乱定义在分离的 translation units（转换单元）中的 non-local static objects（非局部 静态对象）initialization order（初始化顺序）的不确定性。

Things to Remember

手动初始化 built-in type（内建类型）的 objects（对象），因为 C++ 只在某些时候才会 自己初始化它们。

在 constructor（构造函数）中，用 member initialization list（成员初始化列表）代替函 数体中的 assignment（赋值）。initialization list（初始化列表）中 data members（数据 成员）的排列顺序要与它们在 class（类）中被声明的顺序相同。

通过用 local static objects（局部静态对象）代替 non-local static objects（非局部静态对 象）来避免跨 translation units（转换单元）的 initialization order problems（初始化顺序 问题）。

Item 4: 确保 objects（对象）在使用前被初始化

42

Effective C++

Item 5: 了解 C++ 为你偷偷地加上和调用了什么函

数

作者：Scott Meyers

译者：fatalerror99 (iTePub's Nirvana)

发布：http://blog.csdn.net/fatalerror99/

一个 empty class（空类）什么时候将不再是 empty class（空类）？答案是当 C++ 搞定了 它。如果你自己不声明一个 copy constructor（拷贝构造函数），一个 copy assignment operator（拷贝赋值运算符）和一个 destructor（析构函数），编译器就会为这些东西声明一 个它自己的版本。此外，如果你自己根本没有声明 constructor（构造函数），编译器就会为 你声明一个 default constructor（缺省构造函数）。所有这些函数都被声明为 public 和 inline（参见 Item 30）。作为结果，如果你写

class Empty{};

在本质上和你这样写是一样的：

class Empty {
public:
Empty() { ... }		// default constructor
Empty(const Empty& rhs) { ... }		// copy constructor
~Empty() { ... }		// destructor — see below
		// for whether it's virtual

Empty& operator=(const Empty& rhs) { ... } // copy assignment operator

};

这些函数只有在它们被需要的时候才会生成，但是并不需要做太多的事情，就会用到它们。 下面的代码会促使每一个函数生成：

Empty e1;	// default constructor;
	// destructor
Empty e2(e1);	// copy constructor
e2 = e1;	// copy assignment operator

假设编译器为你写了这些函数，那么它们做些什么呢？default constructor（缺省构造函数）

和destructor（析构函数）主要是给编译器一个地方放置 "behind the scenes" code（“幕后”代 码）的，诸如 base classes（基类）和 non-static data members（非静态数据成员）的

Item 5: 了解 C++ 为你偷偷地加上和调用了什么函数

43

Effective C++

constructors（构造函数）和 destructor（析构函数）的调用。注意，生成的 destructor（析构 函数）是 non-virtual（非虚拟）的（参见 Item 7），除非它所在的 class（类）是从一个 base class（基类）继承而来，而 base class（基类）自己声明了一个 virtual destructor（虚 拟析构函数）（这种情况下，函数的 virtualness（虚拟性）来自 base class（基类））。

对于 copy constructor（拷贝构造函数）和 copy assignment operator（拷贝赋值运算符）， compiler-generated versions（编译器生成版本）只是简单地从 source object（源对象）拷贝 每一个 non-static data member（非静态数据成员）到 target object（目标对象）。例如，考 虑一个 NamedObject template（模板），它允许你将名字和类型为 T 的 objects（对象）联 系起来的：

template<typename T> class NamedObject { public:

NamedObject(const char *name, const T& value); NamedObject(const std::string& name, const T& value);

...

private:

std::string nameValue;

TobjectValue;

};

因为 NamedObject 中声明了一个 constructors（构造函数），编译器就不会再生成一个 default constructor（缺省构造函数）。这一点很重要，它意味着如果你小心地设计一个 class（类），使它需要 constructor arguments（构造函数参数），你就不必顾虑编译器会不 顾你的决定，轻率地增加一个不需要参数的 constructors（构造函数）。

NamedObject 既没有声明 copy constructor（拷贝构造函数）也没有声明 copy assignment operator（拷贝赋值运算符），所以编译器将生成这些函数（如果需要它们的话）。看，这就

是copy constructor（拷贝构造函数）的用法：

NamedObject<int> no1("Smallest Prime Number", 2);

NamedObject<int> no2(no1);

// calls copy constructor

编译器生成的 copy constructor（拷贝构造函数）一定会用 no1.nameValue 和 no1.objectValue 分别初始化 no2.nameValue 和 no2.objectValue。nameValue 的类型是 string，标准 string 类型有一个 copy constructor（拷贝构造函数），所以将通过以 no1.nameValue 作为参数调用 string 的 copy constructor（拷贝构造函数）初始化 no2.nameValue。而另一方面，NamedObject<int>::objectValue 的类型是 int（因为在这个 template instantiation（模板实例化）中 T 是 int），而 int 是 built-in type（内建类型），所以 将通过拷贝 no1.objectValue 的每一个二进制位初始化 no2.objectValue。

Item 5: 了解 C++ 为你偷偷地加上和调用了什么函数

44

Effective C++

编译器为 NamedObject<int> 生成的 copy assignment operator（拷贝赋值运算符）本质上也 会有同样的行为，但是，通常情况下，只有在结果代码合法而且有一个合理的可理解的巧合 时，compiler-generated（编译器生成）的 copy assignment operator（拷贝赋值运算符）才 会有我所描述的行为方式。如果这两项检测中的任一项失败了，编译器将拒绝为你的 class（类）生成一个 operator=。

例如，假设 NamedObject 如下定义，nameValue 是一个 reference to a string（引向一个字 符串的引用），而 objectValue 是一个 const T：

template<class T> class NamedObject { public:

//this ctor no longer takes a const name, because nameValue

//is now a reference-to-non-const string. The char* constructor

//is gone, because we must have a string to refer to. NamedObject(std::string& name, const T& value);

...		// as above, assume no
		// operator= is declared
private:
std::string& nameValue;		// this is now a reference
const T objectValue;		// this is now const
};

现在，考虑这里会发生什么：

std::string newDog("Persephone");
std::string oldDog("Satch");
NamedObject<int> p(newDog, 2);		// when I originally wrote this, our
		// dog Persephone was about to
NamedObject<int> s(oldDog, 36);		// have her second birthday
		// the family dog Satch (from my
		// childhood) would be 36 if she
		// were still alive
p = s;		// what should happen to
		// the data members in p?

assignment（赋值）之前，p.nameValue 和 s.nameValue 都引向 string objects（对象），虽 然并非同一个。那个 assignment（赋值）对 p.nameValue 产生了什么影响呢？ assignment（赋值）之后，p.nameValue 所引向的 string 是否就是 s.nameValue 所引向的那 一个呢，也就是说，reference（引用）本身被改变了？如果是这样，就违反了常规，因为 C++ 并没有提供使一个 reference（引用）引向另一个 objects（对象）的方法。换一种思 路，是不是 p.nameValue 所引向的那个 string objects（对象）被改变了，从而影响了其他 objects（对象）—— pointers（指针）或 references（引用）持续指向的那个 string，也就 是，赋值中并没有直接涉及到的对象？这是 compiler-generated（编译器生成）的 copy assignment operator（拷贝赋值运算符）应该做的事情吗？

Item 5: 了解 C++ 为你偷偷地加上和调用了什么函数

45

Effective C++

面对这个难题，C++ 拒绝编译代码。如果你希望一个包含 reference member（引用成员）的 class（类）支持 assignment（赋值），你必须自己定义 copy assignment operator（拷贝赋 值运算符）。对于含有 const members（const 成员）的 classes（类），编译器会有类似的 行为（就像上面那个改变后的 class（类）中的 objectValue）。改变 const members（const 成员）是不合法的，所以编译器隐式生成的 assignment function（赋值函数）无法确定该如 何对待它们。最后，如果 base classes（基类）将 copy assignment operator（拷贝赋值运算 符）声明为 private，编译器拒绝为从它继承的 derived classes（派生类）生成 implicit copy assignment operators（隐式拷贝赋值运算符）。毕竟，编译器为派生类生成的 copy assignment operator（拷贝赋值运算符）也要处理其 base class parts（基类构件）（参见 Item 12），但如果这样做，它们当然无法调用那些 derived classes（派生类）无权调用的 member functions（成员函数）。

Things to Remember

编译器可以隐式生成一个 class（类）的 default constructor（缺省构造函数），copy constructor（拷贝构造函数），copy assignment operator（拷贝赋值运算符）和 destructor（析构函数）。

Item 5: 了解 C++ 为你偷偷地加上和调用了什么函数

46

Effective C++

Item 6: 如果你不想使用 compiler-generated functions（编译器生成函数），就明确拒绝

作者：Scott Meyers

译者：fatalerror99 (iTePub's Nirvana)

发布：http://blog.csdn.net/fatalerror99/

房地产代理商出售房屋，服务于这样的代理商的软件系统自然要有一个 class（类）来表示被 出售的房屋：

class HomeForSale { ... };

每一个房地产代理商都会很快指出，每一件房产都是独特的——没有两件是完全一样的。在 这种情况下，为 HomeForSale object（对象）做一个 copy（拷贝）的想法就令人不解了。你 怎么能拷贝一个独一无二的东西呢？因此最好让类似这种企图拷贝 HomeForSale object（对 象）的行为不能通过编译：

HomeForSale h1;
HomeForSale h2;
HomeForSale h3(h1);		// attempt to copy h1		— should
		// not compile!
h1 = h2;		// attempt to copy h2		— should
		// not compile!

唉，防止这种编译的方法并非那么简单易懂。通常，如果你不希望一个 class（类）支持某种 功能，你可以简单地不声明赋予它这种功能的函数。这个策略对于 copy constructor（拷贝构 造函数）和 copy assignment operator（拷贝赋值运算符）不起作用，因为，就象 Item 5 中 指出的，如果你不声明它们，而有人又想调用它们，编译器就会替你声明它们。

这就限制了你。如果你不声明 copy constructor（拷贝构造函数）或 copy assignment operator（拷贝赋值运算符），编译器也可以替你生成它们。你的 class（类）还是会支持 copying（拷贝）。另一方面，如果你声明了这些函数，你的 class（类）依然会支持 copying（拷贝）。而我们此时的目的却是 prevent copying（防止拷贝）！

解决这个问题的关键是所有的编译器生成的函数都是 public（公有）的。为了防止生成这些函 数，你必须自己声明它们，但是你没有理由把它们声明为 public（公有）的。相反，应该将 copy constructor（拷贝构造函数）和 copy assignment operator（拷贝赋值运算符）声明为 private（私有）的。通过显式声明一个 member function（成员函数），可以防止编译器生成 它自己的版本，而且将这个函数声明为 private（私有）的，可以防止别人调用它。

Item 6: 如果你不想使用 compiler-generated functions（编译器生成函数），就明确拒绝 47

Effective C++

通常，这个方案并不十分保险，因为 member（成员）和 friend functions（友元函数）还是 能够调用你的 private 函数。换句话说，除非你十分聪明地不 define（定义）它们。那么，当 有人不小心地调用了它们，在 link-time（连接时）会出现错误。这个窍门——声明 member functions（成员函数）为 private 却故意不去实现它——确实很好，在 C++ 的 iostreams 库 里，就有几个类用此方法 prevent copying（防止拷贝）。比如，看一下你用的标准库的实现

中ios_base，basic_ios 和 sentry 的 definitions（定义），你就会看到 copy constructor（拷 贝构造函数）和 copy assignment operator（拷贝赋值运算符）被声明为 private 而且没有被 定义的情况。

将这个窍门用到 HomeForSale 上，很简单：

class HomeForSale { public:

...

private:

...

HomeForSale(const HomeForSale&);// declarations only HomeForSale& operator=(const HomeForSale&);

};

你会注意到，我省略了 functions' parameters（函数参数）的名字。这不是必须的，只是一个 普通的惯例。毕竟，函数不会被实现，更少会被用到，有什么必要指定参数名呢？

对于上面的 class definition（类定义），编译器将阻止客户拷贝 HomeForSale objects（对 象）的企图，如果你不小心在 member（成员）或 friend function（友元函数）中这样做了， 连接程序会提出抗议。

将link-time error（连接时错误）提前到编译时间也是可行的（早发现错误毕竟比晚发现 好），通过不在 HomeForSale 本身中声明 copy constructor（拷贝构造函数）和 copy

assignment operator（拷贝赋值运算符）为 private，而是在一个为 prevent copying（防止拷 贝）而特意设计的 base class（基类）中声明。这个 base class（基类）本身非常简单：

class Uncopyable {
protected:		// allow construction
Uncopyable() {}		// and destruction of
~Uncopyable() {}		// derived objects...
private:
Uncopyable(const Uncopyable&);		// ...but prevent copying
Uncopyable& operator=(const Uncopyable&);
};

为了阻止拷贝 HomeForSale objects（对象），我们现在必须让它从 Uncopyable 继承：

class HomeForSale: private Uncopyable {	// class no longer
...	// declares copy ctor or
};	// copy assign. operator

Item 6: 如果你不想使用 compiler-generated functions（编译器生成函数），就明确拒绝 48

Effective C++

这样做是因为，如果有人——甚至是 member（成员）或 friend function（友元函数）——试 图拷贝一个 HomeForSale objects（对象），编译器将试图生成一个 copy constructor（拷贝 构造函数）和一个 copy assignment operator（拷贝赋值运算符）。就象 Item 12 解释的，这 些函数的 compiler-generated versions（编译器生成版）会试图调用 base class（基类）的相 应函数，而这些调用将被拒绝，因为在 base class（基类）中，拷贝操作是 private（私有）

的。

Uncopyable 的实现和使用包含一些微妙之处，比如，从 Uncopyable 继承不必是 public（公 有）的（参见 Item 32 和 39），而且 Uncopyable 的 destructor（析构函数）不必是 virtual（虚拟）的（参见 Item 7）。因为 Uncopyable 不包含数据，所以它符合 Item 39 描述

的empty base class optimization（空基类优化）的条件，但因为它是 base class（基类）， 此项技术的应用不能引入 multiple inheritance（多继承）（参见 Item 40）。反过来说，

multiple inheritance（多继承）有时会使 empty base class optimization（空基类优化）失效 （还是参见 Item 39）。通常，你可以忽略这些微妙之处，而且仅仅像此处演示的这样来使用 Uncopyable，因为它的工作就像在做广告。你还可以使用在 Boost（参见 Item 55）中的一个 可用版本。那个 class（类）名为 noncopyable。那是一个好东西，我只是发现那个名字有点

儿un-（不……）嗯…… nonnatural（非自然）。

Things to Remember

为了拒绝编译器自动提供的机能，将相应的 member functions（成员函数）声明为 private，而且不要给出 implementations（实现）。使用一个类似 Uncopyable 的 base class（基类）是方法之一。

Item 6: 如果你不想使用 compiler-generated functions（编译器生成函数），就明确拒绝 49