现代C++编程实战:132个核心技巧示例(原书第2版)电子书

前言

Chapter 1 第1章 现代C++的核心特性

1.1 尽可能地使用auto关键字

1.1.1 使用方式

1.1.2 工作原理

1.1.3 延伸阅读

1.2 创建类型别名和模板别名

1.2.1 使用方式

1.2.2 工作原理

1.2.3 延伸阅读

1.3 理解统一初始化

1.3.1 准备工作

1.3.2 使用方式

1.3.3 工作原理

1.3.4 更多

1.3.5 延伸阅读

1.4 了解各种形式的非静态成员初始化

1.4.1 使用方式

1.4.2 工作原理

1.4.3 延伸阅读

1.5 控制以及查询对象对齐方式

1.5.1 准备工作

1.5.2 使用方式

1.5.3 工作原理

1.5.4 延伸阅读

1.6 使用作用域枚举

1.6.1 使用方式

1.6.2 工作原理

1.6.3 延伸阅读

1.7 在虚方法中使用override和final关键字

1.7.1 准备工作

1.7.2 使用方式

1.7.3 工作原理

1.7.4 延伸阅读

1.8 使用基于range的for循环迭代range

1.8.1 准备工作

1.8.2 使用方式

1.8.3 工作原理

1.8.4 延伸阅读

1.9 对自定义类型使用基于range的for循环

1.9.1 准备工作

1.9.2 使用方式

1.9.3 工作原理

1.9.4 延伸阅读

1.10 使用explicit构造函数和转换操作符来避免隐式转换

1.10.1 准备工作

1.10.2 使用方式

1.10.3 工作原理

1.10.4 延伸阅读

1.11 使用匿名命名空间来代替静态全局空间

1.11.1 准备工作

1.11.2 使用方式

1.11.3 工作原理

1.11.4 延伸阅读

1.12 使用内联命名空间进行符号版本控制

1.12.1 准备工作

1.12.2 使用方式

1.12.3 工作原理

1.12.4 延伸阅读

1.13 使用结构化绑定处理多值返回

1.13.1 准备工作

1.13.2 使用方式

1.13.3 工作原理

1.13.4 更多

1.13.5 延伸阅读

1.14 使用类模板参数推导简化代码

1.14.1 使用方式

1.14.2 工作原理

1.14.3 延伸阅读

Chapter 2 第2章 数字和字符串

2.1 在数值类型和字符串类型之间进行转换

2.1.1 准备工作

2.1.2 使用方式

2.1.3 工作原理

2.1.4 延伸阅读

2.2 数值类型的极限和其他属性

2.2.1 准备工作

2.2.2 使用方式

2.2.3 工作原理

2.2.4 延伸阅读

2.3 生成伪随机数

2.3.1 准备工作

2.3.2 使用方式

2.3.3 工作原理

2.3.4 延伸阅读

2.4 初始化伪随机数生成器内部状态的所有位

2.4.1 准备工作

2.4.2 使用方式

2.4.3 工作原理

2.4.4 延伸阅读

2.5 创建cooked的用户自定义字面量

2.5.1 准备工作

2.5.2 使用方式

2.5.3 工作原理

2.5.4 更多

2.5.5 延伸阅读

2.6 创建原始的用户自定义字面量

2.6.1 准备工作

2.6.2 使用方式

2.6.3 工作原理

2.6.4 延伸阅读

2.7 使用原始字符串字面量来避免转义字符

2.7.1 准备工作

2.7.2 使用方式

2.7.3 工作原理

2.7.4 延伸阅读

2.8 创建字符串辅助库

2.8.1 准备工作

2.8.2 使用方式

2.8.3 工作原理

2.8.4 延伸阅读

2.9 使用正则表达式验证字符串的格式

2.9.1 准备工作

2.9.2 使用方式

2.9.3 工作原理

2.9.4 更多

2.9.5 延伸阅读

2.10 使用正则表达式解析字符串的内容

2.10.1 准备工作

2.10.2 使用方式

2.10.3 工作原理

2.10.4 延伸阅读

2.11 使用正则表达式替换字符串的内容

2.11.1 准备工作

2.11.2 使用方式

2.11.3 工作原理

2.11.4 延伸阅读

2.12 使用std::string_view代替常量字符串引用

2.12.1 准备工作

2.12.2 使用方式

2.12.3 工作原理

2.12.4 延伸阅读

2.13 使用std::format格式化文本

2.13.1 准备工作

2.13.2 使用方式

2.13.3 工作原理

2.13.4 延伸阅读

2.14 使用std::format格式化用户自定义类型

2.14.1 准备工作

2.14.2 使用方式

2.14.3 工作原理

2.14.4 延伸阅读

Chapter 3 第3章 函数

3.1 实现默认函数和删除函数

3.1.1 准备工作

3.1.2 使用方式

3.1.3 工作原理

3.1.4 延伸阅读

3.2 将lambda与标准算法结合使用

3.2.1 准备工作

3.2.2 使用方式

3.2.3 工作原理

3.2.4 延伸阅读

3.3 使用泛型lambda和模板lambda

3.3.1 准备工作

3.3.2 使用方式

3.3.3 工作原理

3.3.4 延伸阅读

3.4 编写递归lambda

3.4.1 准备工作

3.4.2 使用方式

3.4.3 工作原理

3.4.4 延伸阅读

3.5 编写具有可变数量参数的函数模板

3.5.1 准备工作

3.5.2 使用方式

3.5.3 工作原理

3.5.4 延伸阅读

3.6 使用fold表达式简化可变参数函数模板

3.6.1 准备工作

3.6.2 使用方式

3.6.3 工作原理

3.6.4 更多

3.6.5 延伸阅读

3.7 实现高阶函数map和fold

3.7.1 准备工作

3.7.2 使用方式

3.7.3 工作原理

3.7.4 更多

3.7.5 延伸阅读

3.8 将函数组合成高阶函数

3.8.1 准备工作

3.8.2 使用方式

3.8.3 工作原理

3.8.4 更多

3.8.5 延伸阅读

3.9 统一调用可调用对象

3.9.1 准备工作

3.9.2 使用方式

3.9.3 工作原理

3.9.4 延伸阅读

Chapter 4 第4章 预处理和编译

4.1 条件编译源代码

4.1.1 准备工作

4.1.2 使用方式

4.1.3 工作原理

4.1.4 延伸阅读

4.2 使用间接模式进行预处理器的字符串化和连接

4.2.1 准备工作

4.2.2 使用方式

4.2.3 工作原理

4.2.4 延伸阅读

4.3 使用static_assert执行编译时断言检查

4.3.1 准备工作

4.3.2 使用方式

4.3.3 工作原理

4.3.4 延伸阅读

4.4 使用enable_if条件编译类和函数

4.4.1 准备工作

4.4.2 使用方式

4.4.3 工作原理

4.4.4 更多

4.4.5 延伸阅读

4.5 在编译时使用constexpr if选择分支

4.5.1 准备工作

4.5.2 使用方式

4.5.3 工作原理

4.5.4 延伸阅读

4.6 向编译器提供带有属性的元数据

4.6.1 使用方式

4.6.2 工作原理

4.6.3 延伸阅读

Chapter 5 第5章 标准库容器、算法和迭代器

5.1 使用vector作为默认容器

5.1.1 准备工作

5.1.2 使用方式

5.1.3 工作原理

5.1.4 延伸阅读

5.2 对固定大小的位序列使用bitset

5.2.1 准备工作

5.2.2 使用方式

5.2.3 工作原理

5.2.4 更多

5.2.5 延伸阅读

5.3 对可变大小的位序列使用vector<bool>

5.3.1 准备工作

5.3.2 使用方式

5.3.3 工作原理

5.3.4 更多

5.3.5 延伸阅读

5.4 使用位操作工具

5.4.1 准备工作

5.4.2 使用方式

5.4.3 工作原理

5.4.4 延伸阅读

5.5 在range内查找元素

5.5.1 准备工作

5.5.2 使用方式

5.5.3 工作原理

5.5.4 延伸阅读

5.6 对range进行排序

5.6.1 准备工作

5.6.2 使用方式

5.6.3 工作原理

5.6.4 延伸阅读

5.7 初始化range

5.7.1 准备工作

5.7.2 使用方式

5.7.3 工作原理

5.7.4 延伸阅读

5.8 在range上使用set操作

5.8.1 准备工作

5.8.2 使用方式

5.8.3 工作原理

5.8.4 延伸阅读

5.9 使用迭代器向容器中插入新元素

5.9.1 准备工作

5.9.2 使用方式

5.9.3 工作原理

5.9.4 更多

5.9.5 延伸阅读

5.10 编写自己的随机访问迭代器

5.10.1 准备工作

5.10.2 使用方式

5.10.3 工作原理

5.10.4 更多

5.10.5 延伸阅读

5.11 使用非成员函数访问容器

5.11.1 准备工作

5.11.2 使用方式

5.11.3 工作原理

5.11.4 更多

5.11.5 延伸阅读

Chapter 6 第6章 通用工具

6.1 使用chrono::duration表示时间间隔

6.1.1 准备工作

6.1.2 使用方式

6.1.3 工作原理

6.1.4 更多

6.1.5 延伸阅读

6.2 使用日历

6.2.1 准备工作

6.2.2 使用方式

6.2.3 工作原理

6.2.4 更多

6.2.5 延伸阅读

6.3 在时区之间转换时间

6.3.1 准备工作

6.3.2 使用方式

6.3.3 工作原理

6.3.4 延伸阅读

6.4 使用标准时钟测量函数执行时间

6.4.1 准备工作

6.4.2 使用方式

6.4.3 工作原理

6.4.4 延伸阅读

6.5 为自定义类型生成哈希值

6.5.1 准备工作

6.5.2 使用方式

6.5.3 工作原理

6.5.4 延伸阅读

6.6 使用std::any存储任意值

6.6.1 准备工作

6.6.2 使用方式

6.6.3 工作原理

6.6.4 延伸阅读

6.7 使用std::optional存储可选值

6.7.1 准备工作

6.7.2 使用方式

6.7.3 工作原理

6.7.4 延伸阅读

6.8 使用std::variant作为类型安全联合体

6.8.1 准备工作

6.8.2 使用方式

6.8.3 工作原理

6.8.4 更多

6.8.5 延伸阅读

6.9 访问std::variant

6.9.1 准备工作

6.9.2 使用方式

6.9.3 工作原理

6.9.4 延伸阅读

6.10 对连续对象序列使用std::span

6.10.1 准备工作

6.10.2 使用方式

6.10.3 工作原理

6.10.4 延伸阅读

6.11 注册一个在程序正常退出时调用的函数

6.11.1 准备工作

6.11.2 使用方式

6.11.3 工作原理

6.11.4 延伸阅读

6.12 使用类型特征获取类型的属性

6.12.1 准备工作

6.12.2 使用方式

6.12.3 工作原理

6.12.4 更多

6.12.5 延伸阅读

6.13 自定义类型特征

6.13.1 准备工作

6.13.2 使用方式

6.13.3 工作原理

6.13.4 延伸阅读

6.14 使用std::conditional在类型之间进行选择

6.14.1 准备工作

6.14.2 使用方式

6.14.3 工作原理

6.14.4 延伸阅读

Chapter 7 第7章 文件和流

7.1 读写原始数据

7.1.1 准备工作

7.1.2 使用方式

7.1.3 工作原理

7.1.4 更多

7.1.5 延伸阅读

7.2 读写对象

7.2.1 准备工作

7.2.2 使用方式

7.2.3 工作原理

7.2.4 延伸阅读

7.3 使用流的本地化设置

7.3.1 准备工作

7.3.2 使用方式

7.3.3 工作原理

7.3.4 延伸阅读

7.4 使用I/O流操作符控制流的输出

7.4.1 准备工作

7.4.2 使用方式

7.4.3 工作原理

7.4.4 延伸阅读

7.5 使用货币I/O流操作符

7.5.1 准备工作

7.5.2 使用方式

7.5.3 工作原理

7.5.4 延伸阅读

7.6 使用时间I/O流操作符

7.6.1 准备工作

7.6.2 使用方式

7.6.3 工作原理

7.6.4 延伸阅读

7.7 使用文件系统路径

7.7.1 准备工作

7.7.2 使用方式

7.7.3 工作原理

7.7.4 延伸阅读

7.8 创建、复制和删除文件及目录

7.8.1 准备工作

7.8.2 使用方式

7.8.3 工作原理

7.8.4 延伸阅读

7.9 从文件中删除内容

7.9.1 准备工作

7.9.2 使用方式

7.9.3 工作原理

7.9.4 延伸阅读

7.10 检查现有文件或目录的属性

7.10.1 准备工作

7.10.2 使用方式

7.10.3 工作原理

7.10.4 延伸阅读

7.11 枚举目录的内容

7.11.1 准备工作

7.11.2 使用方式

7.11.3 工作原理

7.11.4 更多

7.11.5 延伸阅读

7.12 查找文件

7.12.1 准备工作

7.12.2 使用方式

7.12.3 工作原理

7.12.4 延伸阅读

Chapter 8 第8章 线程和并发

8.1 线程的使用

8.1.1 准备工作

8.1.2 使用方式

8.1.3 工作原理

8.1.4 延伸阅读

8.2 用互斥量和锁同步访问共享数据

8.2.1 准备工作

8.2.2 使用方式

8.2.3 工作原理

8.2.4 延伸阅读

8.3 避免使用递归互斥量

8.3.1 准备工作

8.3.2 使用方式

8.3.3 工作原理

8.3.4 延伸阅读

8.4 处理线程函数抛出的异常

8.4.1 准备工作

8.4.2 使用方式

8.4.3 工作原理

8.4.4 延伸阅读

8.5 在线程之间发送通知

8.5.1 准备工作

8.5.2 使用方式

8.5.3 工作原理

8.5.4 延伸阅读

8.6 使用promise和future从线程返回值

8.6.1 准备工作

8.6.2 使用方式

8.6.3 工作原理

8.6.4 更多

8.6.5 延伸阅读

8.7 异步执行函数

8.7.1 准备工作

8.7.2 使用方式

8.7.3 工作原理

8.7.4 延伸阅读

8.8 使用原子类型

8.8.1 准备工作

8.8.2 使用方式

8.8.3 工作原理

8.8.4 延伸阅读

8.9 基于线程实现并行map和fold

8.9.1 准备工作

8.9.2 使用方式

8.9.3 工作原理

8.9.4 延伸阅读

8.10 基于任务实现并行map和fold

8.10.1 准备工作

8.10.2 使用方式

8.10.3 工作原理

8.10.4 更多

8.10.5 延伸阅读

8.11 基于标准并行算法实现并行map和fold

8.11.1 准备工作

8.11.2 使用方式

8.11.3 工作原理

8.11.4 更多

8.11.5 延伸阅读

8.12 使用可结合的线程和取消机制

8.12.1 准备工作

8.12.2 使用方式

8.12.3 工作原理

8.12.4 延伸阅读

8.13 使用线程同步机制

8.13.1 准备工作

8.13.2 使用方式

8.13.3 工作原理

8.13.4 延伸阅读

Chapter 9 第9章 鲁棒性和性能

9.1 使用异常进行错误处理

9.1.1 准备工作

9.1.2 使用方式

9.1.3 工作原理

9.1.4 更多

9.1.5 延伸阅读

9.2 对于不抛出异常的函数使用noexcept

9.2.1 使用方式

9.2.2 工作原理

9.2.3 更多

9.2.4 延伸阅读

9.3 保证程序的常量正确性

9.3.1 使用方式

9.3.2 工作原理

9.3.3 更多

9.3.4 延伸阅读

9.4 创建编译时常量表达式

9.4.1 准备工作

9.4.2 使用方式

9.4.3 工作原理

9.4.4 更多

9.4.5 延伸阅读

9.5 创建即时函数

9.5.1 使用方式

9.5.2 工作原理

9.5.3 延伸阅读

9.6 执行正确类型转换

9.6.1 使用方式

9.6.2 工作原理

9.6.3 更多

9.6.4 延伸阅读

9.7 使用unique_ptr拥有单独的内存资源

9.7.1 准备工作

9.7.2 使用方式

9.7.3 工作原理

9.7.4 延伸阅读

9.8 使用shared_ptr共享内存资源

9.8.1 准备工作

9.8.2 使用方式

9.8.3 工作原理

9.8.4 延伸阅读

9.9 实现移动语义

9.9.1 准备工作

9.9.2 使用方式

9.9.3 工作原理

9.9.4 更多

9.9.5 延伸阅读

9.10 基于operator<=>的一致性比较

9.10.1 准备工作

9.10.2 使用方式

9.10.3 工作原理

9.10.4 延伸阅读

Chapter 10 第10章 模式和惯用法

10.1 在工厂模式中避免重复的if...else语句

10.1.1 准备工作

10.1.2 使用方式

10.1.3 工作原理

10.1.4 更多

10.1.5 延伸阅读

10.2 实现pimpl惯用法

10.2.1 准备工作

10.2.2 使用方式

10.2.3 工作原理

10.2.4 更多

10.2.5 延伸阅读

10.3 实现命名参数惯用法

10.3.1 准备工作

10.3.2 使用方式

10.3.3 工作原理

10.3.4 延伸阅读

10.4 基于非虚接口惯用法将接口与实现分离

10.4.1 准备工作

10.4.2 使用方式

10.4.3 工作原理

10.4.4 延伸阅读

10.5 用律师与委托人惯用法处理友元

10.5.1 准备工作

10.5.2 使用方式

10.5.3 工作原理

10.5.4 延伸阅读

10.6 基于奇异递归模板模式的静态多态

10.6.1 准备工作

10.6.2 使用方式

10.6.3 工作原理

10.6.4 更多

10.6.5 延伸阅读

10.7 实现线程安全单例

10.7.1 准备工作

10.7.2 使用方式

10.7.3 工作原理

10.7.4 更多

10.7.5 延伸阅读

Chapter 11 第11章 测试框架

11.1 开始使用Boost.Test

11.1.1 准备工作

11.1.2 使用方式

11.1.3 工作原理

11.1.4 更多

11.1.5 延伸阅读

11.2 基于Boost.Test编写和运行测试

11.2.1 准备工作

11.2.2 使用方式

11.2.3 工作原理

11.2.4 延伸阅读

11.3 基于Boost.Test的断言

11.3.1 准备工作

11.3.2 使用方式

11.3.3 工作原理

11.3.4 延伸阅读

11.4 基于Boost.Test使用测试固件

11.4.1 准备工作

11.4.2 使用方式

11.4.3 工作原理

11.4.4 延伸阅读

11.5 基于Boost.Test控制输出

11.5.1 准备工作

11.5.2 使用方式

11.5.3 工作原理

11.5.4 更多

11.5.5 延伸阅读

11.6 开始使用Google Test

11.6.1 准备工作

11.6.2 使用方式

11.6.3 工作原理

11.6.4 更多

11.6.5 延伸阅读

11.7 基于Google Test编写和运行测试

11.7.1 准备工作

11.7.2 使用方式

11.7.3 工作原理

11.7.4 延伸阅读

11.8 基于Google Test的断言

11.8.1 使用方式

11.8.2 工作原理

11.8.3 延伸阅读

11.9 基于Google Test使用测试固件

11.9.1 准备工作

11.9.2 使用方式

11.9.3 工作原理

11.9.4 延伸阅读

11.10 基于Google Test控制输出

11.10.1 准备工作

11.10.2 使用方式

11.10.3 工作原理

11.10.4 延伸阅读

11.11 开始使用Catch2

11.11.1 准备工作

11.11.2 使用方式

11.11.3 工作原理

11.11.4 更多

11.11.5 延伸阅读

11.12 基于Catch2编写和运行测试

11.12.1 使用方式

11.12.2 工作原理

11.12.3 延伸阅读

11.13 基于Catch2的断言

11.13.1 准备工作

11.13.2 使用方式

11.13.3 工作原理

11.13.4 延伸阅读

11.14 基于Catch2控制输出

11.14.1 准备工作

11.14.2 使用方式

11.14.3 工作原理

11.14.4 延伸阅读

Chapter 12 第12章 C++20核心特性

12.1 模块的使用

12.1.1 准备工作

12.1.2 使用方式

12.1.3 工作原理

12.1.4 延伸阅读

12.2 理解模块分区

12.2.1 准备工作

12.2.2 使用方式

12.2.3 工作原理

12.2.4 更多

12.2.5 延伸阅读

12.3 基于概念指定模板参数要求

12.3.1 准备工作

12.3.2 使用方式

12.3.3 工作原理

12.3.4 更多

12.3.5 延伸阅读

12.4 使用要求表达式和要求条款

12.4.1 准备工作

12.4.2 使用方式

12.4.3 工作原理

12.4.4 延伸阅读

12.5 基于range库遍历集合

12.5.1 准备工作

12.5.2 使用方式

12.5.3 工作原理

12.5.4 更多

12.5.5 延伸阅读

12.6 创建你自己的range视图

12.6.1 准备工作

12.6.2 使用方式

12.6.3 工作原理

12.6.4 延伸阅读

12.7 为异步计算创建协程任务类型

12.7.1 准备工作

12.7.2 使用方式

12.7.3 工作原理

12.7.4 更多

12.7.5 延伸阅读

12.8 为序列值创建协程生成器类型

12.8.1 准备工作

12.8.2 使用方式

12.8.3 工作原理

12.8.4 更多

12.8.5 延伸阅读

参考资料