EffectiveCpp on Mao's Blog

5-Implementations

Thu, 21 May 2026 10:32:00 +0800

上一章讲的是接口设计的原则，而这一章关注具体的实现细节。

Item26: Postpone variable definitions as long as possible

本节告诉我们，尽可能推迟变量的定义位置。换言之，在程序逻辑不变的情况下，越晚定义变量越好。

为什么？考虑到两个问题：

开销问题：变量定义太早，而程序由于某种原因没有继续执行（比如抛出异常）导致该变量未被使用，那么变量定义时调用构造函数的开销，相当于白费了。
代码风格：如果析构的位置不变，那么变量定义得越早，它的生命周期就越长，影响的代码范围就越广。而 coding 的一大原则就是“解耦”，尽可能减少每个部分对其他部分的影响。

所以说，只有在你马上需要用到这个变量的时候，才去定义它，而不是提早定义。

并且，最好在定义时就直接做完初始化的工作（开销更小），而不是先定义再赋值（开销更大）

前者在构造时只需要调用一次对应的 constructor
后者要调用 default constructor 和 copy assignment operator

作者的原话如下：

“Not only should you postpone a variable’s definition until right before you have to use the variable, you should also try to postpone the definition until you have initialization arguments for it.” (Dulimov, p. 115)

意思是一定要“忍到”你能够初始化（initialization）这个变量之后，你再去定义（definition）它。一定要将两者绑定，才能实现性能和资源利用最大化。

那么有人问了：如果在循环中需要使用某个变量，是在循环外部定义之后再在循环内部赋值好（方案 A），还是直接在循环内部构造好（方案 B）。

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


// Approach A
Widget w;
for (int i = 0; i < n; i++) {
 w = some value dependent on i;
}

// Approach B
for (int i = 0; i < n; i++) {
 Widget w(some value dependent on i);
}

可以看下两种方案各自的开销：

4-Designs and Declarations

Sat, 09 May 2026 20:39:00 +0800

本章将介绍设计和声明 C++ 接口的一些原则。

Item18: Make interfaces easy to use correctly and hard to use incorrectly

核心思想：

好的接口应该引导正确使用，阻止错误使用。如果用户用错了，编译器应该报错，而不是运行时才发现 bug。

所以，我们在设计接口的时候，最好多问自己一个问题：

如果别人用我的接口，最可能的几种用错方式是什么？我能不能在编译期就拦住，从而让用户正确地使用接口？

具体来说，主要有下面四个点需要检查：

参数顺序容易搞混吗？ -> 用类型区分
参数有合法范围吗？ -> 用 enum 或者 enum class 限定范围
行为和内置类型一致吗？ -> 该 const 就 const，该重载运算符就重载
涉及资源管理吗？ -> 返回智能指针，不要返回裸指针

参数顺序容易搞混吗？

比如说，我有一个 Date 类，它的构造函数需要三个参数：month-day-year。如果我全都定义成 int 类型，那么在传错顺序时很难检查出来。

所以，我可以自定义新的三个类：Month、Day 和 Year。

1
2
3
4
5
6
7
8


// 危险：三个 int，顺序很容易传反
Date(int month, int day, int year);

// 改进：用类型区分
struct Month { explicit Month(int m); };
struct Day { explicit Day(int d); };
struct Year { explicit Year(int y); };
Date(const Month& m, const Day& d, const Year& y);

这样，就可以轻松区分下面三种情况，用户很难传错参数：

3-Resource Management

Sat, 02 May 2026 09:27:30 +0800

C++中，我们需要手动管理资源。最常见的资源就是动态分配的内存，但注意，它不是唯一的资源。其他资源还有：file descriptors, mutex locks, fonts and brushes in graphical user interfaces.

Item13: Use objects to manage resouces

核心思想：把资源放进对象里，用对象来管理资源，让对象的构造和析构来保证资源的获取与释放。

其实，这就是 RAII。

这是因为，C++没有垃圾回收机制，手动 new / delete 十分容易出错（比如 delete 可能因为一些异常情况而没有被执行），所以我们需要一个规范化的获取和释放资源的流程。

手动管理资源的做法

例如，下面的代码使用一个 factory function 来为所有继承自 Investment 的类创建统一的调用接口（一个基类指针）。

如果你手动管理资源（new / delete、fopen / fclose、lock / unlock），很容易出错：

1
2
3
4
5


void f() {
 Investment* pInv = createInvestment();
 // ... 中间可能有 return、异常、goto 等各种出口
 delete pInv; // 万一没走到这里？内存泄漏
}

当然，你可以说：啊我 coding 的时候很仔细的，不会犯这样的低级错误。

但是，随着工程越来越大，代码越来越长，不规范的写法维护的成本也会越来越高。所以，为了确保资源一定能够安全释放，我们还是使用 RAII 的做法。

RAII 的做法

用一个对象来持有资源，对象的析构函数负责释放资源。

auto_ptr 就是这样一个对象。它是一个智能指针，管理着一个裸指针；在自身析构时，会自动对自己管理的裸指针调用 delete。

再次回顾：<code>delete</code> 实际做了两件事情

2-Constructors, Destructors, and Assignment Operators

Tue, 28 Apr 2026 12:26:00 +0800

构造函数、析构函数、赋值运算符，可以说是一个对象最重要的三个成员函数，它们分别掌管成员变量的出生、死亡以及变化。

Item5: Know what functions C++ silently writes and calls

虽然我们只是创建一个空类，没有写任何的函数，但是，编译器还是会默认声明一些特殊的成员函数。具体来说，包括：

函数	说明
默认构造函数	`Empty() = default;`
析构函数	`~Empty() = default;`
拷贝构造函数	`Empty(const Empty&) = default;`
拷贝赋值运算符	`Empty& operator=(const Empty&) = default;`
移动构造函数	`Empty(Empty&&) = default;`
移动赋值运算符	`Empty& operator=(Empty&&) = default;`

【补充知识】五法则：

除了默认构造函数之外，剩下的五个特殊的成员函数，如果我们手动定义了其中一个，剩下的四个就都不会被编译器自动生成。这是因为，一旦我们需要手动定义这五个函数中的一个，就说明存在需要手动释放的资源（比如 new 出的内存、打开的文件、拿到的锁等等）。既然有资源需要手动释放，那么默认的拷贝（浅拷贝）一定会出问题——两个对象会持有同一份资源，析构时双重释放。

这个规则被称为“五法则”，其逻辑链是：需要自定义某个函数 → 说明持有资源 → 拷贝/移动不能信任默认实现 → 五个都要自定义

回到正题。比如说，我们定义：

1

class Empty{};

但实际上，编译器生成的等价于：

 1
 2
 3
 4
 5
 6
 7
 8
 9
10


// 编译器实际生成的等价于
class Empty {
public:
 Empty() = default;
 ~Empty() = default;
 Empty(const Empty&) = default;
 Empty& operator=(const Empty&) = default;
 Empty(Empty&&) = default;
 Empty& operator=(Empty&&) = default;
};

这些函数都是 public 并且 inline 的，且只有它们在被实际调用的时候，编译器才会真正生成它们的定义（不是在声明时就生成）。

1-AccustomingYourselfToC++

Thu, 23 Apr 2026 08:17:01 +0800

Item1: View Cpp as a federation of languages

C++可以看成是下面四种不同语言的组合：

C 语言
面向对象的 C++：主要针对封装、多态、继承、虚函数等等。
模板 C++：主要针对泛型编程。
The STL（标准模板库）：最常用且特别的模板库。

每种对应不同的策略，需要根据情况选择对应的策略。

Note

Rules for effective C++ programming vary, depending on the part of C++ you are using.

Item2: Prefer `consts`, `enums` and `inlines` to `#define`

#define 在 preprocess 阶段完成，而前面三个关键字都是在 compile 阶段完成的。

符号表：symbol table。这个概念和编译的关系是？符号表似乎就是一个存了所有变量名字的大表吧。

#define 出来的东西本质上不是变量，不会进到符号表里面，这给我们 debug 带来困难。

代码体积更小（不会有多余的 copy），含义更加明确。

两类特殊情况：

Constant pointer：需要指针值和指针指向的指都被定义成常量，这样这个常量才算真正的“常量”。
Class-specific constants：限制一个常量的作用域在这个类内部，则这个常量是这个类的成员。并且，为了使得这个常量只有一个 copy，还要声明其为 static 类型。

1
2
3
4
5


class GamePlayer {
private:
 static const int NumTurns = 5;
 int scores[NumTurns];
};

上面是对 NumTurns 这个常量的 declaration，而不是 definition。这两个有什么区别吗？

EffectiveCpp on Mao's Blog

5-Implementations

Item26: Postpone variable definitions as long as possible

4-Designs and Declarations

Item18: Make interfaces easy to use correctly and hard to use incorrectly

参数顺序容易搞混吗？

3-Resource Management

Item13: Use objects to manage resouces

手动管理资源的做法

RAII 的做法

2-Constructors, Destructors, and Assignment Operators

Item5: Know what functions C++ silently writes and calls

1-AccustomingYourselfToC++

Item1: View Cpp as a federation of languages

Item2: Prefer consts, enums and inlines to #define

Item2: Prefer `consts`, `enums` and `inlines` to `#define`