现代C++ 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);
}

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

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 的，且只有它们在被实际调用的时候，编译器才会真正生成它们的定义（不是在声明时就生成）。

default和delete

Thu, 16 Oct 2025 09:05:16 +0800

`default` 关键字强制生成默认构造函数

模拟面试开始

面试官： 我们知道，如果一个类我们不给它定义任何构造函数，编译器会自动为我们生成一个默认构造函数。类似的，编译器也可能会为我们生成拷贝构造函数、拷贝赋值运算符等。

在 C++11 之后，如果我们想显式地告诉编译器：“请为我生成一个默认的、最普通的版本”，我们可以使用 default 关键字。

请看下面这个例子：

1
2
3
4
5
6
7
8
9


class MyClass {
public:
 MyClass() = default; // 显式地要求编译器生成默认构造函数

 MyClass(int val) : data(val) {} // 用户自定义了别的构造函数

private:
 int data;
};

我的问题是： 在这个例子中，MyClass() = default; 这一行代码，有什么实际意义？

换句话说，如果我们删掉 MyClass() = default; 这一行，会发生什么变化？这个类还能通过 MyClass obj; 这种方式创建对象吗？为什么？

回答：

当用户自己定义了一种构造函数时，编译器就不会自动生成默认的无参数的构造函数。
MyClass() = default; 确保无参数的构造函数存在。
如果删去这一行，那么 MyClass 这个类就无法通过 MyClass obj; 这种方式创建对象，因为编译器检测不到对应的构造函数。
而增加上这一行，可以使得程序可以在无参数的情况下创建新的对象，等到对其内容有要求时，再做修改。

面试官 (总结与肯定): 你说的没错。这个问题的核心在于 C++ 的一条规则：

一旦用户为类定义了任何一种构造函数（无论带不带参数），编译器就会“罢工”，不再自动生成默认（无参）构造函数。

所以，在你给出的例子中：

因为你已经定义了一个 MyClass(int val)，编译器就不会再自动生成 MyClass() 了。
如果我们删掉 MyClass() = default; 这一行，那么 MyClass 类就没有无参构造函数。此时，MyClass obj; 这样的代码就会编译失败，因为它找不到匹配的构造函数。

= default 的作用： MyClass() = default; 这一行，就是你（程序员）在向编译器明确地下指令：

using关键字

Wed, 24 Sep 2025 09:26:08 +0800

`using` 声明和 `using` 指令

面试官： 在 C++ 中，using 关键字有多种用途。我们先来聊聊它最常见的两种用法：using 声明 (using-declaration) 和 using 指令 (using-directive)。

请问，下面这两行代码，它们分别属于哪一种？它们在作用和影响范围上，有什么本质的区别？

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18


// 场景一
#include <iostream>

void func1() {
 using std::cout; // 这是什么？
 cout << "Hello";
}

// 场景二
#include <iostream>
#include <vector>

using namespace std; // 这又是什么？

void func2() {
 cout << "World";
 vector<int> v;
}

回答：

using std::cout 属于 using 声明，它只引入命名空间中的单个成员，作用在当前作用域中，适合局部使用。
using namespace std 属于 using 指令，它负责引入整个命名空间，作用在全局，但容易导致二义性问题。

面试官 (总结与肯定): 你说的完全正确。

NULL和nullptr

Thu, 18 Sep 2025 08:33:33 +0800

`nullptr` 解决函数重载的二义性

面试官： 在 C++11 之前，我们通常使用一个宏 NULL 来表示空指针。而在 C++11 中，引入了一个新的关键字 nullptr 来专门表示空指针。

请问，我们为什么需要 nullptr？或者说，使用宏 NULL 在某些情况下，会带来什么样的问题或歧义，是 nullptr 能够解决的？

回答：

NULL 是一个宏，它除了表示空指针之外，更常用的含义是表示 0，一个整数。
由于 NULL 既能表示空指针，又能表示 0，因此它会引发歧义。
比如，某个函数重载了两个版本，一个的参数类型是 int，而另一个参数类型是 char*。当输入 NULL 时，通常会调用参数为 int 的那个版本。
而使用 nullptr 则规避了这一风险。nullptr 是一个真正的空指针常量，它是一个特殊的类型 std::nullptr_t，可以隐式地转换为任何的指针类型，而不会和 int 类型混淆。

面试官 (总结与肯定): 你说的完全正确。我们来把这个过程再详细地梳理一遍。nullptr 诞生的核心原因是解决函数重载时的二义性。

NULL 的“前世今生” NULL 是一个定义在 <cstddef> 等头文件中的预处理宏。它的具体定义取决于编译器，但通常是下面两种之一：

1
2
3
4
5


#define NULL 0
// 或者
#define NULL 0L
// 或者在 C++ 编译器中，有时甚至是
#define NULL nullptr // 这是现代编译器的“向后兼容”行为

在 C++98/03 的时代，你可以认为 NULL 就是一个值为 0 的整型常量。

Cpp字符串处理

Mon, 15 Sep 2025 09:21:27 +0800

`std::string` 的优点

面试官： 在 C++ 中，我们有两种主要的方式来表示字符串：C++ 标准库提供的 std::string 类，以及从 C 语言继承来的、以空字符 \0 结尾的字符数组（我们常说的 C 风格字符串，通常用 char* 或 const char* 指针来表示）。

请问，和传统的 C 风格字符串相比，使用 std::string 类有什么主要的优点？

回答：

std::string 的封装程度更好，使用时不易出错。
具体来说，包括自动内存管理、安全性和功能性三个方面。

面试官 (补充与扩展): 你说的完全正确。std.string 作为一个类，把所有复杂的、容易出错的底层操作都封装起来了，为我们提供了极大的便利和安全保障。

我来帮你把它的优点展开成几个具体的点，这也是面试时希望听到的内容：

自动内存管理 (Automatic Memory Management)：
- std::string: string 对象自己会负责管理存储字符串所需的内存。当字符串变长时，它会自动扩容；当 string 对象被销毁时，它会自动释放内存。你完全不需要操心 new[] 和 delete[]。
- char*: 你必须手动管理内存。malloc / free 或 new[] / delete[] 必须成对出现，极其容易忘记释放，导致内存泄漏。
安全性 (Safety)：
- std::string: 它内部记录了字符串的当前长度。
  - 成员函数 length() 或 size() 可以 O (1) 复杂度地返回长度。
  - 成员函数 at(i) 提供边界检查，越界会抛出异常。
  - 拼接、拷贝等操作都会自动处理内存，不会造成缓冲区溢出。
- char*:
  - 长度信息依赖于结尾的 \0。每次计算长度 (strlen) 都需要从头遍历，时间复杂度 O (n)。
  - 所有操作（如 strcpy, strcat）都不进行边界检查，如果目标缓冲区不够大，就会发生缓冲区溢出，这是 C/C++ 中最危险的安全漏洞之一。
功能丰富且易用 (Rich Functionality)：

Cpp的三种类型推导关键字

Sun, 14 Sep 2025 09:33:26 +0800

`auto` 关键字

面试官： C++11 引入了 auto 关键字，它极大地改变了我们编写 C++ 代码的方式。

你能简单解释一下，auto 关键字的作用是什么吗？使用它有什么好处？

回答：

auto 关键字的作用是，省略具体的变量类型，而是根据实际变量的类型推导出其类型。
使用 auto 关键字，就不必写复杂的类型名（比如常用的 STL 迭代器），让代码看上去更简洁。
同时，auto 关键字还能实现类似“多态”的效果（这里说“多态”不太准确，应该说，是泛型编程），使得同一份代码可以被许多不同的类型复用。

面试官 (补充与澄清): 你说的很对。我们来把你的回答再精确化和补充一下。

auto 的作用： 它是一个类型占位符。编译器会在编译时，根据变量的初始化表达式，自动推导出变量应该具有的正确类型。

auto 的好处：

简洁性 (Brevity)：正如你所说，它可以避免写冗长、复杂的类型名。这一点在处理 STL 的迭代器和模板时尤其明显。

1
2
3
4
5


// C++03
std::vector<std::string>::iterator it = my_vec.begin();

// C++11 with auto
auto it = my_vec.begin(); // 简洁、易读、不易出错

正确性 (Correctness)：auto 保证了变量的类型与初始化表达式的类型完全匹配，避免了因手写类型错误或发生意外的类型转换而导致的 bug。
可维护性 (Maintainability)：如果初始化表达式的类型未来发生了变化（比如一个函数的返回值从 int 变成了 long long），使用了 auto 的代码不需要任何修改，会自动适应新的类型。

关于你提到的“多态效果”： 这个描述非常有趣！auto 本身是在编译期进行类型推导，不直接产生运行时的多态（那需要虚函数）。但你说的“使得同一份代码可以被许多不同的类型复用”，这个思想非常接近泛型编程 (Generic Programming)。 auto 在 C++14 的泛型 Lambda 中 [](auto x){ ... } 和 C++20 的函数参数中 void func(auto param)，确实扮演了类似模板参数的角色，让一段代码能适用于多种类型。你的直觉是非常准的。

Lambda表达式

Sat, 13 Sep 2025 18:22:44 +0800

什么是 Lambda 表达式？

面试官： 好的，我们来聊聊 C++11 引入的一个非常强大的特性——Lambda 表达式。

你能用自己的话简单解释一下，Lambda 表达式是什么吗？它主要解决了什么问题，或者说，它为我们编写 C++ 代码带来了什么样的便利？

回答：

我的理解是，lambda 表达式就是“匿名函数”，即省略名字的函数。
它定义了一个函数，这个函数有函数的所有功能，但不需要名字。
这让我们在需要写一些小巧的工具性一次性函数时，省去了从头定义函数的麻烦，让代码看上去更加简洁。

面试官 (补充与肯定): 你说的完全正确。Lambda 表达式的出现，极大地改变了 C++ 的编程风格，特别是与标准库算法（STL Algorithms）结合使用时。

在 C++11 之前，如果我们需要给 std::sort, std::find_if 这样的算法传递一个自定义的比较或判断逻辑，我们通常需要：

在别处定义一个完整的具名函数。
或者定义一个函数对象（一个重载了 operator() 的 struct 或 class）。

这两种方式都比较繁琐，并且会导致逻辑和使用点的分离。

而 Lambda 表达式，正如你所说，允许我们在需要的地方，就地定义一个匿名的、小巧的函数，让代码更紧凑、可读性也更强。

Lambda 表达式的捕获列表

面试官 (深入提问): 好的，你对 Lambda 的基本概念很清楚。我们来看一下 Lambda 表达式的语法结构。

一个完整的 Lambda 表达式看起来像这样： [ captures ] ( params ) -> return_type { body }

其中，[ captures ] 这个部分，我们称之为捕获列表 (Capture List)，这是 Lambda 表达式最强大、也最核心的部分。

vector的内部实现和优化

Sat, 06 Sep 2025 09:27:46 +0800

`vector` 在内存中如何存储数据？和 `array` 的区别？

面试官： 我看你写的代码里经常使用 std::vector。你能简单描述一下 std::vector 在内存中是如何存储数据的吗？它和普通的 C 风格数组（比如 int arr[10]）有什么主要的区别？

回答：

对于这个问题，我并不太了解，我谈一谈我粗浅的看法。
首先，vector 应该是基于数组 array 实现的，其底层就是一块动态分配的、连续的内存数组。这是 vector 能够支持快速随机访问的根本原因。但是，vector 肯定有它自身的优化在。
边界检查：
- array 只管给你分配一段连续的内存，其他的管理你都要自己来，也不会管你数组 idx 是否越界；
- 在 vector 中，如果用 [] 操作符，那么行为和 array 一样，不会管你越界与否；
- 但是，vector 提供了 at() 这个成员函数，vec.at(i) 会进行边界检查。如果 i 越界，vector 会抛出 std::out_of_range 异常。这说明 vector 的安全性更好。
自动初始化：
- 再比如，定义 array 时，程序不会帮我们自动初始化，array 中可能有一些奇怪的原始数据（随机值）；
- 但是，定义 vector 时，程序会帮我们自动初始化。

不过，我没有提到 vector 和 array 最重要的区别：（根据 Gemini 的解释补充）

Vector 的大小是动态可变的，可以不断地 push_back 新的元素，而 array 的大小是固定的。
这就是 vector 的动态扩容机制。

`vector` 的扩容机制 (Reallocation)

面试官 (补充与追问): 你说得很好。vector 最大的特点就是它的大小是动态可变的。我们可以不断地对它 push_back 新的元素。

现代C++ on Mao's Blog

5-Implementations

Item26: Postpone variable definitions as long as possible

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

default和delete

default 关键字强制生成默认构造函数

using关键字

using 声明和 using 指令

NULL和nullptr

nullptr 解决函数重载的二义性

Cpp字符串处理

std::string 的优点

Cpp的三种类型推导关键字

auto 关键字

Lambda表达式

什么是 Lambda 表达式？

Lambda 表达式的捕获列表

vector的内部实现和优化

vector 在内存中如何存储数据？和 array 的区别？

vector 的扩容机制 (Reallocation)

`default` 关键字强制生成默认构造函数

`using` 声明和 `using` 指令

`nullptr` 解决函数重载的二义性

`std::string` 的优点

`auto` 关键字

`vector` 在内存中如何存储数据？和 `array` 的区别？

`vector` 的扩容机制 (Reallocation)