CHAPTER 01 · 语言基础
入门:从源码到程序
一句话总览:C++ 源码要经过「预处理 → 编译 → 汇编 → 链接」四道工序才变成可执行程序,理解这条流水线,后面 90% 的编译报错你都能自己定位。
🏭
生活化类比
把写程序想成做一本书:预处理是「把引用的资料复印插进来」(#include),编译是「把中文稿翻译成机器语」(生成汇编),汇编是「排版成印刷版」(生成 .o 目标文件),链接是「把各章节和图书馆的公共资料装订成册」(合并 .o 与库文件,产出 exe)。
把写程序想成做一本书:预处理是「把引用的资料复印插进来」(#include),编译是「把中文稿翻译成机器语」(生成汇编),汇编是「排版成印刷版」(生成 .o 目标文件),链接是「把各章节和图书馆的公共资料装订成册」(合并 .o 与库文件,产出 exe)。
1.1 第一个程序:解剖 Hello World
hello.cpp
#include <iostream> // 预处理指令:把标准输入输出库的声明"复印"进来
int main() { // main 是程序唯一入口,返回 int 给操作系统
std::cout << "Hello, C++!" << std::endl;
return 0; // 返回 0 = 告诉操作系统"我正常结束了"
}#include <iostream>:尖括号找系统库目录;自己写的头文件用双引号#include "my.h"。std::是命名空间限定,防止不同库的同名函数打架。using namespace std;图省事,但大项目里容易引发名字冲突,推荐按需using std::cout;。<<是流插入运算符,可以链式拼接;std::endl= 换行 + 强制刷新缓冲区(频繁用会拖慢输出,平时用'\n'即可)。
1.2 编译流水线(核心图解)
源码 → 可执行文件的四道工序
编译错误发生在「翻译」阶段;链接错误(undefined reference)发生在「装订」阶段——找不到函数的实现体。
1.3 动手编译(g++ 命令行)
terminal
g++ hello.cpp -o hello # 一条命令走完四道工序,产出 hello
./hello # 运行(Windows 下是 hello.exe)
g++ -std=c++17 -Wall -Wextra -g hello.cpp -o hello
# -std=c++17 指定语言标准 -Wall -Wextra 打开警告(强烈建议)
# -g 带调试信息 -O2 优化(发布时用)
g++ -c a.cpp # 只编译不链接,产出 a.o
g++ a.o b.o -o app # 多个目标文件链接成一个程序⚠ 高频陷阱:undefined reference ≠ 语法错
报 undefined reference to 'foo()' 说明声明找到了、实现没找到:要么忘了把实现所在的 .cpp 一起编译链接,要么函数只声明没定义,要么库没链接(如 -lpthread)。头文件只放声明,实现放 .cpp,这是铁律。✓ 记忆锚点
「编译看语法,链接找实现」。报错信息里带行号指向你的代码 → 编译错;报错指向符号名找不到 → 链接错。1.4 随堂自测
QUIZ 1
#include <iostream> 这行代码是在哪个阶段被处理的?
#include 是预处理指令,预处理器把头文件内容原样"复印"到该位置,此时还没开始真正的语法翻译。所以头文件里的错误,报错行号常常指向被展开的位置。
QUIZ 2
编译通过但报
undefined reference to 'add(int, int)',最可能的原因是?undefined reference 是链接器的抱怨:调用点见过声明(编译过关),但装订所有 .o 时找不到函数体。把实现文件加入编译命令即可。
CHAPTER 02 · 语言基础
变量与数据类型
一句话总览:变量就是「贴了标签的内存盒子」,类型决定盒子多大、能装什么;C++ 是静态强类型语言,盒子规格在编译期就钉死了。
📦
生活化类比
内存是一整面快递柜。声明
内存是一整面快递柜。声明
int a = 10; 相当于:租一个 4 格连排的柜子(int 占 4 字节),贴上标签「a」,放进包裹「10」。类型 = 柜子规格;变量名 = 标签;地址 = 柜门编号。char 是单格小柜,double 是 8 格大柜——规格不符的包裹硬塞就会变形(截断/溢出)。2.1 内置类型一览(64 位平台典型值)
| 类型 | 大小 | 取值范围 / 用途 | 备注 |
|---|---|---|---|
bool | 1 字节 | true / false | 非 0 即 true |
char | 1 字节 | -128 ~ 127,存字符/小整数 | 'A' 本质是 65 |
int | 4 字节 | 约 ±21 亿 | 默认首选整数类型 |
long long | 8 字节 | 约 ±9.2×10¹⁸ | 大数、金额(分)、时间戳 |
unsigned int | 4 字节 | 0 ~ 42.9 亿 | 没有负数,减法易回绕! |
float | 4 字节 | 约 7 位有效数字 | 图形/嵌入式省内存 |
double | 8 字节 | 约 15~16 位有效数字 | 浮点默认首选 |
用 sizeof(类型) 实测大小;跨平台定宽用 <cstdint> 里的 int32_t / int64_t / uint8_t。
同一面内存墙上,不同类型占用的格子数
变量名只是给人看的标签,机器只认「地址 + 按类型解读的字节」。
2.2 初始化:优先用花括号 {}
init.cpp
int a = 10; // 拷贝初始化,传统写法
int b(10); // 直接初始化
int c{10}; // 列表初始化(C++11,推荐!)
int d{}; // 零初始化:d = 0,杜绝"随机垃圾值"
int e{3.7}; // ❌ 编译报错!{} 禁止窄化转换(3.7 → int 会丢精度)
int f = 3.7; // ⚠ 悄悄截断成 3,编译器可能只给警告
auto g = 42; // auto:让编译器根据右侧推导类型 → int
auto h = 3.14; // → double
const double PI = 3.14159; // const:运行期常量,不可修改
constexpr int N = 100 * 4; // constexpr:编译期就能算出的常量⚠ 高频陷阱:未初始化变量
局部变量不初始化,值是内存里残留的随机垃圾,Debug 和 Release 下表现可能完全不同。养成 int n{}; 的习惯,一个花括号保平安。2.3 类型转换与溢出
convert.cpp
int big = 300;
char c = big; // 隐式窄化:300 超出 char 范围 → 结果变成 44(截断)
double x = 7 / 2; // ⚠ x = 3.0!int/int 先做整数除法得 3
double y = 7 / 2.0; // ✓ y = 3.5,有一方是浮点才做浮点除法
unsigned u = 0;
u = u - 1; // ⚠ 不是 -1!无符号回绕成 4294967295
int m = 2147483647; // int 最大值
m = m + 1; // ⚠ 有符号溢出是未定义行为(UB)!
double price = 0.1 + 0.2;
bool ok = (price == 0.3); // ⚠ false!浮点有精度误差
bool ok2 = std::abs(price - 0.3) < 1e-9; // ✓ 用误差范围比较⚠ 三条保命规则
① 整数除法结果还是整数,想要小数让任一操作数变浮点;② unsigned 永远别和负数/减法混搭(for (unsigned i = n-1; i >= 0; --i) 是死循环);③ 浮点判等用误差范围,钱用整数「分」来存。✓ const vs constexpr 一句话
const = 「我承诺不改它」;constexpr = 「编译时就能算出它的值」。数组长度、模板参数需要的是后者。2.4 随堂自测
QUIZ 1
double x = 5 / 2; 执行后 x 的值是?5 和 2 都是 int,先做整数除法得 2,再转成 double 赋给 x,所以是 2.0。写成 5 / 2.0 或 5.0 / 2 才得 2.5。
QUIZ 2
下面哪种写法能在编译期就拦住「把 3.7 塞进 int」这种精度丢失?
列表初始化 {} 禁止窄化转换,double→int 直接编译报错。A/B 静默截断,D 推导成 double 根本没转。这就是推荐 {} 的核心理由。
CHAPTER 03 · 语言基础
运算符与流程控制
一句话总览:程序 = 数据 + 逻辑;if/switch 是「岔路口」,for/while 是「跑圈」,掌握短路求值和边界条件,逻辑题就稳了。
🚦
生活化类比
流程控制就是导航软件:if/else 是「前方路口左转还是右转」;switch 是「按出口编号下高速」;for 是「绕操场跑 10 圈」(次数已知);while 是「一直跑到天黑」(条件驱动);break 是「提前退赛」;continue 是「这一圈不算,跳过剩余路段直接进下一圈」。
流程控制就是导航软件:if/else 是「前方路口左转还是右转」;switch 是「按出口编号下高速」;for 是「绕操场跑 10 圈」(次数已知);while 是「一直跑到天黑」(条件驱动);break 是「提前退赛」;continue 是「这一圈不算,跳过剩余路段直接进下一圈」。
3.1 分支:if 与 switch
branch.cpp
int score = 85;
if (score >= 90) std::cout << "优秀";
else if (score >= 60) std::cout << "及格";
else std::cout << "不及格";
// 三目运算符:简单二选一赋值时更紧凑
std::string tag = (score >= 60) ? "PASS" : "FAIL";
switch (day) { // switch 只接受整型/枚举,不能比字符串
case 1: std::cout << "周一"; break; // break 不写会"贯穿"到下一 case!
case 2: std::cout << "周二"; break;
case 6: // 故意贯穿:6 和 7 共享同一逻辑
case 7: std::cout << "周末"; break;
default: std::cout << "其他";
}循环的执行顺序:for 的四个节拍
注意:④ 步进在循环体之后执行;条件为 false 时循环体一次都不执行(do-while 则至少执行一次)。
3.2 三种循环怎么选
| 循环 | 适用场景 | 特点 |
|---|---|---|
for | 次数已知:遍历数组、跑 n 轮 | 初始化/条件/步进集中一行,最不易漏 |
while | 条件驱动:读到文件尾、等用户输入 | 先判断后执行,可能 0 次 |
do-while | 先做再问:菜单至少展示一次 | 先执行后判断,至少 1 次 |
for (auto x : v) | 范围 for(C++11):遍历容器 | 不碰下标就不会越界,首选 |
loop.cpp
for (int i = 0; i < 5; ++i) { // 0,1,2,3,4 共 5 次
if (i == 2) continue; // 跳过 2
if (i == 4) break; // 到 4 提前结束
std::cout << i << ' '; // 输出: 0 1 3
}
std::vector<int> v{10, 20, 30};
for (int x : v) std::cout << x; // 拷贝每个元素(读)
for (int& x : v) x *= 2; // 引用:能改原容器
for (const auto& x : v) std::cout << x;// 大对象只读遍历的标准姿势3.3 逻辑运算符与短路求值
logic.cpp
// && 与:左边为 false,右边根本不执行(短路)
// || 或:左边为 true,右边根本不执行
if (p != nullptr && p->value > 0) { ... }
// ✓ 安全:p 为空时右边不会执行,避免空指针解引用
// 若把两个条件反过来写,就是经典崩溃 bug
int i = 0;
bool b = (i > 0) && (++i > 0); // ++i 没执行!i 仍是 0
// ⚠ 别把"有副作用的表达式"放在短路右侧
// 经典易错:= 是赋值,== 才是比较
if (x = 5) { ... } // ⚠ 恒为真:把 5 赋给 x,再以 x(5) 作条件
if (x == 5) { ... } // ✓ 比较⚠ 高频陷阱三连
① switch 忘写 break → case 贯穿;② if (a < b < c) 不是数学区间!先算 a<b 得 0/1 再和 c 比,要写 a < b && b < c;③ 循环边界 <= 与 < 差一位就是越界(off-by-one)。3.4 随堂自测
QUIZ 1
执行
int i=0; bool b = (i!=0) && (++i>0); 后 i 的值是?&& 短路:左侧 i!=0 为 false,右侧 ++i 根本不执行,i 保持 0。短路求值既是性能优化,也是空指针保护的常用手段。
QUIZ 2
for 循环中 continue 的作用是?
continue 只"跳过这一圈":跳到 ④++i 再回 ② 判断条件;break 才是彻底退出。注意 while 里 continue 会跳过循环体尾部的自增,容易死循环。
CHAPTER 04 · 语言基础
函数与调用栈
一句话总览:函数是「输入 → 加工 → 输出」的独立车间;每次调用都在内存栈上压入一个栈帧,返回时整帧销毁——这是理解值传递、递归、悬垂引用的钥匙。
🥞
生活化类比
调用栈像叠盘子:main 是最底下的盘子,调用 add 就在上面叠一个新盘子(栈帧),add 再调 helper 又叠一个。只能从最顶上取盘子——所以最后调用的函数最先返回(后进先出)。盘子撤走时,盘上的东西(局部变量)跟着一起消失。
调用栈像叠盘子:main 是最底下的盘子,调用 add 就在上面叠一个新盘子(栈帧),add 再调 helper 又叠一个。只能从最顶上取盘子——所以最后调用的函数最先返回(后进先出)。盘子撤走时,盘上的东西(局部变量)跟着一起消失。
4.1 函数的定义与声明
func.cpp
// 声明(原型):告诉编译器"有这个函数",通常放头文件
int add(int a, int b);
// 定义(实现):函数体,通常放 .cpp
int add(int a, int b) {
return a + b; // return:交出结果 + 立即结束函数
}
void log(const std::string& msg) { // void:不返回任何值
std::cout << msg << '\n';
}
// 默认参数:从右往左给,调用时可省略
int power(int base, int exp = 2) { /*...*/ return 1; }
power(3); // = power(3, 2)
power(3, 4);
// 重载:同名不同参数表,编译器按实参挑最匹配的
int max(int a, int b);
double max(double a, double b); // ✓ 参数类型不同 → 合法重载
// double max(int a, int b); // ❌ 仅返回值不同不算重载!4.2 三种传参方式(重点)
| 方式 | 写法 | 本质 | 何时用 |
|---|---|---|---|
| 值传递 | void f(int x) | 复印一份给函数,改副本不影响原件 | 小类型(int/char/指针) |
| 引用传递 | void f(int& x) | 把原件本人交给函数,改的就是原件 | 需要修改实参 |
| 常引用 | void f(const string& s) | 原件给你看但不许改,零拷贝 | 大对象只读访问(首选) |
pass.cpp
void byValue(int x) { x = 99; } // 改的是复印件
void byRef(int& x) { x = 99; } // 改的是原件
int n = 1;
byValue(n); // n 仍是 1
byRef(n); // n 变成 99
void swap(int& a, int& b) { int t = a; a = b; b = t; } // 经典引用应用4.3 互动演示:亲手压栈 / 弹栈
HANDS-ON DEMO
函数调用栈模拟器
场景:main() 调用 add(a, 4),add 内部又调用 helper(x+y)。点按钮观察栈帧的生死。
⚠ 高频陷阱:返回局部变量的引用/指针
int& bad() { int x = 5; return x; } —— 函数返回瞬间 x 的栈帧已销毁,返回的引用指向「已拆迁的房子」(悬垂引用),读到什么全凭运气。返回值请老老实实用值返回(编译器有返回值优化,不慢)。4.4 递归:函数自己调自己
recursion.cpp
int fact(int n) {
if (n <= 1) return 1; // ① 基线条件:递归的"刹车",必须有!
return n * fact(n - 1); // ② 递归步骤:问题规模必须变小
}
// fact(4) = 4 * fact(3) = 4*3*fact(2) = 4*3*2*fact(1) = 24
// 压栈: fact(4)→fact(3)→fact(2)→fact(1),再逐层弹栈把结果乘回去⚠ 递归两要素
没有基线条件或规模不减小 → 无限压栈 → 栈溢出崩溃(stack overflow)。栈空间通常只有几 MB,深递归(如 10 万层)请改循环或显式栈。斐波那契朴素递归是指数级重复计算,要加记忆化。4.5 随堂自测
QUIZ 1
想在函数内部修改调用者的变量,参数应该声明为?
引用 & 让形参成为实参的别名,函数内的修改直达原件。A 是复印件;C/D 带 const 禁止修改。
QUIZ 2
int& f() { int x = 5; return x; } 的问题在于?编译能过(可能只有警告),但运行时 x 已随函数返回被销毁,引用悬垂。这是未定义行为的经典来源,务必值返回或返回堆/静态对象。
CHAPTER 05 · 语言基础
数组与字符串
一句话总览:数组是「一排连号的内存柜子」,下标从 0 开始且不查越界;字符串优先用 std::string(会自动管理内存),C 风格字符数组只做了解。
🏨
生活化类比
数组像一层楼的酒店房间:房号连续(内存连续),arr[0] 是第一间。知道首间房号 + 每间宽度,就能算出任意一间的位置——这就是数组随机访问 O(1) 的原理:
数组像一层楼的酒店房间:房号连续(内存连续),arr[0] 是第一间。知道首间房号 + 每间宽度,就能算出任意一间的位置——这就是数组随机访问 O(1) 的原理:
arr[i] 的地址 = 首地址 + i × sizeof(元素)。但酒店没有门卫查房号:arr[100] 哪怕只有 5 间房也照开不误,开进别人家里(越界 = 未定义行为)。5.1 原生数组
array.cpp
int arr[5] = {10, 20, 30, 40, 50}; // 定长数组,长度必须是编译期常量
int a2[5] = {1, 2}; // 不足的补 0 → {1,2,0,0,0}
int a3[] = {1, 2, 3}; // 让编译器数个数 → 长度 3
arr[0] = 99; // 下标 0 ~ 4
int n = sizeof(arr) / sizeof(arr[0]); // 元素个数 = 总字节 / 单个字节
int grid[2][3] = {{1,2,3},{4,5,6}}; // 二维:2 行 3 列,内存仍是一条直线
grid[1][2] = 9; // 第 2 行第 3 列
// C++11 更安全的定长替代品
std::array<int, 5> a4{1,2,3,4,5}; // 有 .size(),可拷贝,可.at()查边界数组在内存中:连续排列 + 地址公式
红色虚线区不属于数组——C++ 不检查下标,越界读写是未定义行为,可能悄悄破坏别的变量。
⚠ 数组退化成指针
数组作为函数参数时退化为首元素指针,长度信息丢失:void f(int a[]) 等价于 void f(int* a),函数内 sizeof(a) 是指针大小而非数组大小。必须额外传长度,或改用 std::array / std::vector / std::span(C++20)。5.2 std::string:现代字符串
string.cpp
#include <string>
std::string s = "Hello";
s += ", C++"; // 直接拼接,自动扩容
s.size(); // 长度 10
s[0]; s.at(0); // [] 不查边界;at() 越界抛异常
s.substr(0, 5); // "Hello":从 0 起取 5 个
s.find("C++"); // 返回下标 7;找不到返回 string::npos
s.replace(0, 5, "Hi"); // "Hi, C++"
s == "Hi, C++"; // ✓ string 可以直接 == 比较内容!
std::string line;
std::getline(std::cin, line); // 读整行(cin >> 遇空格就停)
int n = std::stoi("42"); // 字符串 → int
std::string t = std::to_string(3.14); // 数字 → 字符串
const char* c = s.c_str(); // 转 C 风格(以 '\0' 结尾),对接 C 接口用ℹ C 风格字符串(了解即可)
char buf[6] = "Hello"; 实际占 6 字节——末尾藏着结束符 '\0'。比较内容要用 strcmp(== 比的是地址),拼接用 strcat 且要自己保证缓冲区够大。历史包袱多,新代码一律 std::string。✓ 选型口诀
长度编译期固定 → std::array;长度运行期变化 → std::vector;文本 → std::string;只读文本参数 → std::string_view(C++17,零拷贝)。原生数组留给底层和面试题。5.3 随堂自测
QUIZ 1
int a[5]={1,2}; 中 a[3] 的值是?提供了初始化列表但元素不足时,剩余元素被值初始化(int 补 0)。完全不给初始化列表的局部数组才是垃圾值。
QUIZ 2
把数组传给函数
void f(int a[]),函数内 sizeof(a)(64 位平台)得到?数组传参退化为 int* 指针,sizeof 得到指针本身的 8 字节。长度信息在传递中丢失,这就是必须额外传 n 或改用容器的原因。
CHAPTER 06 · 内存与指针
指针与引用
一句话总览:指针是「存地址的变量」——一张写着房间号的纸条;引用是「变量的别名」——同一个人的小名。指针可改指向、可为空;引用绑定后从一而终。
🗝️
生活化类比
指针 = 写着门牌号的纸条:纸条本身可以撕了重写别的门牌号(改指向),也可以是空白纸条(nullptr);按纸条找上门开门拿东西 = 解引用
指针 = 写着门牌号的纸条:纸条本身可以撕了重写别的门牌号(改指向),也可以是空白纸条(nullptr);按纸条找上门开门拿东西 = 解引用
*p。引用 = 小名:「润曦」和「肖俊」是同一个人,起小名那一刻就绑定死了,之后喊哪个名字都是操作同一个本体。房子拆了纸条还在 → 悬垂指针,按旧地址上门就闯祸了。6.1 指针基本功
pointer.cpp
int a = 10;
int* p = &a; // & 取地址:p 里存的是 a 的门牌号
*p = 20; // * 解引用:顺着地址找到 a 本体并修改 → a 变 20
p = nullptr; // 空指针:明确表示"不指向任何对象"(C++11)
int** pp = &p; // 二级指针:存"指针变量"的地址
**pp = 30; // 两层解引用,最终还是改到 a
// 指针运算:+1 走一个"元素",不是一个字节
int arr[3] = {1, 2, 3};
int* q = arr; // 数组名退化为首元素指针
q + 1; // 指向 arr[1](地址 +4 字节)
*(q + 2); // = arr[2] = 3,arr[i] 本质就是 *(arr+i)
// const 与指针:从右往左读
const int* p1; // 指向常量的指针:不能改 *p1,能改 p1 指向
int* const p2 = &a; // 常量指针:能改 *p2,p2 指向不能变
const int* const p3 = &a; // 都不能改6.2 互动演示:指针的指向与解引用
HANDS-ON DEMO
指针遥控器
指针 p 可以改指向不同变量;*p 永远操作「当前指向的那个本体」。点按钮感受一下。
6.3 引用:更安全的别名
reference.cpp
int a = 10;
int& r = a; // r 是 a 的别名,必须声明即绑定,且不能改绑
r = 20; // a 变 20(r 和 a 是同一块内存)
int b = 5;
r = b; // ⚠ 不是改绑!这是把 b 的值赋给 a → a=5
const int& cr = a; // 只读别名
const int& t = 42; // ✓ 常引用可绑定字面量(延长临时量寿命)
// int& t2 = 42; // ❌ 普通引用不能绑字面量| 对比项 | 指针 int* p | 引用 int& r |
|---|---|---|
| 本质 | 独立变量,存地址 | 目标变量的别名(编译器通常用指针实现) |
| 可为空 | 可以(nullptr) | 不可以,必须绑定有效对象 |
| 改指向 | 随时可改 | 绑定后终身不变 |
| 使用语法 | 需 *p / &a,有运算 | 和本体用法完全一样 |
| 典型场景 | 可选参数、遍历、动态内存、数据结构 | 函数传参、范围 for、运算符重载 |
✓ 选择口诀
「能引用就不指针」:参数传递优先引用(不为空、语法干净);需要「可空 / 可改指向 / 指针运算」时才用指针,且现代 C++ 中裸指针只观察不持有,持有交给智能指针(第 15 章)。⚠ 三大夺命指针
① 野指针:未初始化就解引用(int* p; *p=1;)——声明即置 nullptr;② 悬垂指针:指向已销毁的栈变量或已 delete 的堆内存——释放后置空;③ 空指针解引用:用前判空,或利用 && 短路保护。这三种全是未定义行为,崩溃现场往往离案发现场很远,极难排查。6.4 随堂自测
QUIZ 1
int a=1,b=2; int& r=a; r=b; 执行后 a 的值是?引用一旦绑定终身不改。r=b 是赋值操作:通过别名 r 把 b 的值写进 a。想"改绑"只能用指针。
QUIZ 2
int arr[4]; int* p = arr; p += 2; 后 p 指向?(int 为 4 字节)指针加减以「所指类型的大小」为单位:p+2 前进 2×4=8 字节,正好落在 arr[2]。这也是指针必须带类型的原因——它得知道一步跨多远。
CHAPTER 07 · 内存与指针
内存模型与动态分配
一句话总览:程序内存分五大区;栈自动管理、快但小,堆手动管理、大但危险;new/delete 必须成对,现代 C++ 用 RAII 让「资源随对象生死自动管理」。
🍽️
生活化类比
栈 = 食堂托盘:进门自动发、吃完自动收,秩序井然速度飞快,但托盘堆高度有限(几 MB)。堆 = 自助仓储:想租多大租多大(GB 级),但钥匙在你手里——租了不退(内存泄漏),仓库迟早爆满;退了还拿旧钥匙开门(悬垂指针),就是事故。RAII 就是「租仓库时签个自动退租协议」:保管员(对象)离场时自动退租。
栈 = 食堂托盘:进门自动发、吃完自动收,秩序井然速度飞快,但托盘堆高度有限(几 MB)。堆 = 自助仓储:想租多大租多大(GB 级),但钥匙在你手里——租了不退(内存泄漏),仓库迟早爆满;退了还拿旧钥匙开门(悬垂指针),就是事故。RAII 就是「租仓库时签个自动退租协议」:保管员(对象)离场时自动退租。
7.1 程序内存五区图
一个 C++ 进程的内存布局(地址从高到低)
栈向下长、堆向上长,两者共享中间的空闲区。栈溢出(深递归/巨型局部数组)与堆耗尽(泄漏)是两种不同的死法。
7.2 new / delete:成对的艺术
heap.cpp
int* p = new int(42); // 堆上申请一个 int,初始化为 42
delete p; // 归还内存
p = nullptr; // 好习惯:防止悬垂指针二次使用
int* arr = new int[100]; // 堆上数组
delete[] arr; // ⚠ 数组必须 delete[],用 delete 是 UB!
// new 做了两件事:① operator new 分配原始内存 ② 在这块内存上调用构造函数
// delete 也两件事:① 调析构函数 ② 释放内存
// malloc/free 只做内存分配/释放,不调构造析构 → C++ 对象别用它们⚠ 内存事故四件套
① 泄漏:new 了没 delete(尤其函数中途 return / 抛异常跳过了 delete);② 重复释放:同一地址 delete 两次 → 崩溃;③ 错配:new[] 配 delete、malloc 配 delete;④ 使用已释放内存(use-after-free)。检测工具:AddressSanitizer(g++ -fsanitize=address)、Valgrind。7.3 RAII:C++ 最核心的思想
RAII(资源获取即初始化):把资源(内存/文件/锁)的生命周期绑定到栈对象上——构造时获取,析构时释放。栈对象离开作用域必然析构(哪怕抛异常),资源就必然归还。
raii.cpp
class FileGuard {
FILE* fp;
public:
FileGuard(const char* path) : fp(fopen(path, "r")) {} // 构造 = 获取
~FileGuard() { if (fp) fclose(fp); } // 析构 = 释放
FILE* get() const { return fp; }
};
void read() {
FileGuard f("data.txt"); // 打开文件
if (something_wrong()) return; // 提前返回?没关系!
throw std::runtime_error("oops"); // 抛异常?也没关系!
// 离开作用域时 f 析构 → fclose 必然执行,绝不泄漏
}
// 标准库全是 RAII:vector/string 管内存,lock_guard 管锁,
// unique_ptr/shared_ptr 管堆对象 —— 你几乎不需要手写 new/delete✓ 记忆锚点
「栈对象的死亡是可靠的,堆内存的释放是不可靠的」——所以让可靠的栈对象去管理不可靠的堆资源。这一句话就是智能指针、容器、锁守卫的全部设计哲学。7.4 随堂自测
QUIZ 1
int* a = new int[10]; 正确的释放方式是?new[] 必须配 delete[],它会对每个元素调析构并正确归还整块数组内存。delete 只处理第一个元素,行为未定义;置空指针只是断开联系,内存依然泄漏。
QUIZ 2
RAII 能保证「抛异常时资源也不泄漏」,靠的是?
C++ 没有 GC。异常传播时进行栈展开(stack unwinding),沿途所有已构造的栈对象都会调析构——把释放逻辑写进析构函数,就搭上了这趟"必然执行"的顺风车。
CHAPTER 08 · 面向对象
类与封装
一句话总览:类 = 数据 + 操作这些数据的函数打包成的「自定义类型」;封装就是把内脏藏起来(private),只留操作面板(public 接口),外界无法把对象改成非法状态。
📱
生活化类比
类就是一台手机的设计图纸,对象是按图纸造出的具体手机。封装:电池芯片全焊死在壳里(private 成员),你只能用屏幕和按键(public 成员函数)。你不能徒手改电压,只能通过「充电接口」——接口内部保证电压安全。封装的价值不是藏,而是保证对象永远处于合法状态:余额不能为负、年龄不能是 -5。
类就是一台手机的设计图纸,对象是按图纸造出的具体手机。封装:电池芯片全焊死在壳里(private 成员),你只能用屏幕和按键(public 成员函数)。你不能徒手改电压,只能通过「充电接口」——接口内部保证电压安全。封装的价值不是藏,而是保证对象永远处于合法状态:余额不能为负、年龄不能是 -5。
8.1 定义一个类
account.cpp
class BankAccount {
private: // 内脏:外界不可直接触碰
std::string owner;
double balance = 0; // 类内默认值(C++11)
public: // 操作面板:外界唯一入口
BankAccount(std::string name) : owner(std::move(name)) {}
void deposit(double amt) { // 存钱:接口负责守住规则
if (amt > 0) balance += amt;
}
bool withdraw(double amt) {
if (amt <= 0 || amt > balance) return false; // 拒绝非法操作
balance -= amt;
return true;
}
double getBalance() const { return balance; } // const:承诺不改成员
};
BankAccount acc("肖俊"); // 用类创建对象(实例化)
acc.deposit(100);
// acc.balance = -999; // ❌ 编译报错!private 挡住了非法状态封装:private 内脏 + public 面板
所有对数据的修改都必须经过 public 接口,接口就是「合法性关卡」。
8.2 this 指针与 static 成员
this_static.cpp
class Counter {
int value = 0; // 每个对象各有一份
static int total; // 静态成员:全类共享一份,属于类不属于对象
public:
Counter& inc() {
++value; ++total;
return *this; // this:指向"当前对象"的指针
} // 返回 *this 支持链式调用 c.inc().inc()
static int getTotal() { return total; } // 静态函数:没有 this,
}; // 只能访问静态成员,可用 Counter::getTotal() 调
int Counter::total = 0; // 静态成员要在类外定义(C++17 可用 inline 免掉)- 成员函数只有一份代码,所有对象共用;调用
a.inc()时编译器悄悄把 &a 作为 this 传进去,函数里访问 value 其实是 this->value。 - const 成员函数(如 getBalance() const)承诺不修改对象,const 对象只能调 const 函数。
- 友元 friend:授权某个函数/类访问自己的 private,是封装的「后门」,慎用(operator<< 重载常用)。
✓ 设计口诀
「数据一律 private,接口最小化 public」。每多暴露一个 public 数据成员,就多一处无法管控的修改点。需要纯数据打包(无不变式)时才用 struct 全 public。8.3 随堂自测
QUIZ 1
class 和 struct 在 C++ 中的唯一本质区别是?
C++ 的 struct 是功能完整的类:能有函数、构造、继承、模板。唯一区别是默认成员访问权和默认继承方式(struct public / class private)。内存位置取决于你怎么创建对象,与关键字无关。
QUIZ 2
静态成员函数为什么不能访问普通(非静态)成员变量?
普通成员每个对象一份,访问它必须知道"哪个对象"——靠 this。静态函数通过类名直接调用,不绑定任何对象,没有 this,自然无法定位到某份普通成员。
CHAPTER 09 · 面向对象
构造与析构:对象的一生
一句话总览:构造函数负责「出生时把资源备齐」,析构函数负责「死亡时把资源还清」;含指针成员的类必须自己写拷贝构造(深拷贝),否则默认浅拷贝会引发双重释放。
👶
生活化类比
构造函数是出生证明 + 入住手续:对象一诞生就自动办妥(初始化成员、申请资源)。析构函数是退租清算:对象销毁前自动执行(还内存、关文件)。浅拷贝像两个人共用一把出租屋钥匙——一人退租(析构)把房退了,另一人还拿钥匙开门 → 事故(双重释放)。深拷贝是给第二个人另租一间一模一样的房。
构造函数是出生证明 + 入住手续:对象一诞生就自动办妥(初始化成员、申请资源)。析构函数是退租清算:对象销毁前自动执行(还内存、关文件)。浅拷贝像两个人共用一把出租屋钥匙——一人退租(析构)把房退了,另一人还拿钥匙开门 → 事故(双重释放)。深拷贝是给第二个人另租一间一模一样的房。
9.1 构造函数家族
ctor.cpp
class Widget {
int id;
std::string name;
const int tag;
public:
Widget() : id(0), name("none"), tag(0) {} // 默认构造(无参)
Widget(int i, std::string n, int t)
: id(i), name(std::move(n)), tag(t) {} // 带参构造 + 初始化列表
Widget(const Widget& other) // 拷贝构造
: id(other.id), name(other.name), tag(other.tag) {}
~Widget() { /* 释放资源 */ } // 析构:无参无返回,只一个
};
Widget w1; // 调默认构造
Widget w2(7, "屏", 1); // 调带参构造
Widget w3 = w2; // ⚠ 这是"拷贝构造",不是赋值!对象诞生时的复制
Widget w4{w2}; // 同上
w1 = w2; // 已存在的对象 → 拷贝赋值 operator=
// explicit:禁止隐式转换构造
class Meter { public: explicit Meter(int cm); };
// Meter m = 100; // ❌ explicit 挡住了 int → Meter 的悄悄转换
Meter m2(100); // ✓ 显式构造ℹ 初始化列表 vs 函数体内赋值
: name(n) 是直接构造成员;函数体内 name = n; 是「先默认构造再赋值」两步走。const 成员、引用成员、无默认构造的类成员只能用初始化列表。养成全部用初始化列表的习惯,顺序按成员声明顺序(不是列表书写顺序)。9.2 对象生命周期图解
一个栈对象从生到死
构造与析构严格镜像对称:成员按声明顺序构造,按逆序析构。
9.3 深拷贝 vs 浅拷贝(必考必错)
deepcopy.cpp
class Buffer {
int* data;
size_t n;
public:
Buffer(size_t size) : data(new int[size]), n(size) {}
~Buffer() { delete[] data; }
// ❌ 不写拷贝构造 → 编译器默认"逐成员复制":只复制指针值(浅拷贝)
// 两个对象的 data 指向同一块堆内存 → 析构两次 → double free 崩溃
Buffer(const Buffer& o) : data(new int[o.n]), n(o.n) { // ✓ 深拷贝
std::copy(o.data, o.data + n, data); // 另开一块内存,复制内容
}
Buffer& operator=(const Buffer& o) { // ✓ 拷贝赋值也要配套写
if (this == &o) return *this; // 防自赋值 a = a
delete[] data; // 先释放自己旧资源
data = new int[o.n]; n = o.n;
std::copy(o.data, o.data + n, data);
return *this;
}
};⚠ 三法则 / 五法则 / 零法则
三法则:需要自定义「析构 / 拷贝构造 / 拷贝赋值」之一,通常三个都要写。五法则(C++11):再加上移动构造 / 移动赋值(第 16 章)。零法则(最优):成员全用 vector/string/智能指针,让编译器生成的默认版本就是对的——你一个都不写。9.4 随堂自测
QUIZ 1
类含裸指针成员且析构中 delete 它,若不写拷贝构造,复制对象后最可能发生?
默认拷贝构造逐成员复制,指针只复制地址值(浅拷贝)。两个对象析构各 delete 一次同一地址 → 重复释放。这正是三法则存在的理由。
QUIZ 2
const 成员变量必须在哪里初始化?
const 成员一生只能初始化一次。进入构造函数体时成员已经"出生",再赋值就是修改 const → 非法。所以只能在出生那一刻——初始化列表——给值。引用成员同理。
CHAPTER 10 · 面向对象
继承:站在父类的肩膀上
一句话总览:继承表达「is-a」关系(狗是动物),派生类自动获得基类的成员并可扩展/重写;但「组合优于继承」——能用「有一个」表达的就别用「是一个」。
🧬
生活化类比
继承像手机换代:iPhone 17 继承 iPhone 16 的全部功能(基类成员),再新增钛合金边框(派生类新成员),还能改进摄像头算法(重写函数)。老用户会用的操作新机全会——所以任何需要 iPhone 16 的地方都能放一台 17(里氏替换,也是第 11 章多态的基础)。但注意:汽车「有一个」发动机,不是「是一个」发动机——那叫组合。
继承像手机换代:iPhone 17 继承 iPhone 16 的全部功能(基类成员),再新增钛合金边框(派生类新成员),还能改进摄像头算法(重写函数)。老用户会用的操作新机全会——所以任何需要 iPhone 16 的地方都能放一台 17(里氏替换,也是第 11 章多态的基础)。但注意:汽车「有一个」发动机,不是「是一个」发动机——那叫组合。
10.1 基本语法与访问控制
inherit.cpp
class Animal {
protected: // protected:自己和子类能访问,外界不能
std::string name;
public:
Animal(std::string n) : name(std::move(n)) {}
virtual ~Animal() = default; // 基类析构必须 virtual!
void eat() { std::cout << name << " 吃东西\n"; }
virtual void speak() { std::cout << "...\n"; }
};
class Dog : public Animal { // public 继承:is-a
public:
Dog(std::string n) : Animal(std::move(n)) {} // 先构造基类部分
void speak() override { // override:明示重写,写错签名编译器报错
std::cout << name << ": 汪汪!\n";
}
void fetch() { std::cout << "捡球\n"; } // 派生类新增能力
};
Dog d("旺财");
d.eat(); // ✓ 继承来的
d.speak(); // ✓ 重写后的版本
Animal* p = &d; // ✓ 基类指针指向派生类对象(向上转型,安全)
// Dog* q = p; // ❌ 向下转型需 dynamic_cast 且要有虚函数| 基类成员 | public 继承后 | protected 继承后 | private 继承后 |
|---|---|---|---|
public | public | protected | private |
protected | protected | protected | private |
private | 不可直接访问 | 不可直接访问 | 不可直接访问 |
99% 的场景用 public 继承(表达 is-a);private/protected 继承表达「用…实现」,通常可被组合替代。
继承树与对象的内存构成
派生对象 = 基类子对象 + 新增成员。构造顺序:先基类后派生;析构相反。
10.2 三个必须知道的坑
⚠ 坑 1:基类析构不写 virtual
Animal* p = new Dog; delete p; —— 若 ~Animal 不是虚函数,只调基类析构,Dog 部分的资源永不释放(泄漏 + UB)。规则:类只要可能被继承并通过基类指针删除,析构必须 virtual。⚠ 坑 2:对象切片(slicing)
Dog d; Animal a = d; —— 按值拷贝只留下 Animal 部分,Dog 的扩展被「切掉」,多态失效。多态必须通过指针或引用:Animal& a = d;。⚠ 坑 3:菱形继承
D 继承 B 和 C,B、C 都继承 A → D 里有两份 A,二义性。解法:class B : virtual public A(虚继承共享一份 A),但复杂度高——优先重新设计,用组合拆掉菱形。✓ 组合优于继承
继承是最强的耦合(白盒复用,基类改动波及所有子类)。判断标准:能自然说出「B 是一种 A」且 B 处处可替换 A → 继承;只是「B 用到 A 的功能」→ 把 A 作为成员(组合)。10.3 随堂自测
QUIZ 1
Animal* p = new Dog(); delete p; 想正确释放 Dog 的全部资源,必须?delete 基类指针时,析构是否分发到派生类取决于基类析构是否 virtual。基类虚析构一旦声明,派生类析构自动也是虚的。
QUIZ 2
下列哪种关系最适合用 public 继承建模?
继承只表达 is-a。汽车"有"发动机、图书馆"有"书、程序员"用"键盘——都是 has-a/uses-a,用组合(成员对象)。只有"正方形是一种图形"是 is-a。
CHAPTER 11 · 面向对象
多态与虚函数:同一指令,各自表演
一句话总览:多态 = 基类指针/引用调用虚函数时,按对象的实际类型在运行期选择实现;底层靠每个对象里的虚指针 vptr 找到所属类的虚函数表 vtable。
🎮
生活化类比
多态像万能遥控器的「开机」键:你对着电视按,电视亮屏;对着空调按,空调出风。按键(基类接口 speak())只有一个,效果由电器本体(实际对象类型)决定。你写「遍历所有电器逐个按开机」的代码时,根本不需要知道每台是什么——新买台投影仪(新派生类),老代码一行不改照样能用。这就是开闭原则:对扩展开放,对修改关闭。
多态像万能遥控器的「开机」键:你对着电视按,电视亮屏;对着空调按,空调出风。按键(基类接口 speak())只有一个,效果由电器本体(实际对象类型)决定。你写「遍历所有电器逐个按开机」的代码时,根本不需要知道每台是什么——新买台投影仪(新派生类),老代码一行不改照样能用。这就是开闭原则:对扩展开放,对修改关闭。
11.1 多态三要素
polymorphism.cpp
class Shape {
public:
virtual double area() const { return 0; } // ① 基类虚函数
virtual ~Shape() = default;
};
class Circle : public Shape {
double r;
public:
Circle(double radius) : r(radius) {}
double area() const override { return 3.14159 * r * r; }
};
class Rect : public Shape {
double w, h;
public:
Rect(double w, double h) : w(w), h(h) {}
double area() const override { return w * h; }
};
// ② 基类指针/引用 ③ 指向派生类对象
std::vector<std::unique_ptr<Shape>> shapes;
shapes.push_back(std::make_unique<Circle>(2));
shapes.push_back(std::make_unique<Rect>(3, 4));
for (const auto& s : shapes)
std::cout << s->area() << '\n'; // 12.566 / 12 —— 各调各的!
// 新增 Triangle 类?这段循环一个字都不用改。11.2 底层机制:vptr 与 vtable(核心图解)
s->area() 在运行期的两步跳转
构造函数负责把 vptr 设为「本类的表」——这就是为什么构造函数里调虚函数不会分发到派生类(此刻 vptr 还指向当前层的表)。
11.3 纯虚函数与抽象类(接口)
interface.cpp
class Drawable { // 抽象类:含纯虚函数,不能实例化
public:
virtual void draw() = 0; // = 0:纯虚,子类必须实现
virtual ~Drawable() = default;
};
// Drawable d; // ❌ 抽象类不能创建对象
class Button : public Drawable {
public:
void draw() override { /* 画按钮 */ } // 不实现的话 Button 也是抽象类
};
// final:禁止再被继承/重写
class Seal final : public Button {}; // Seal 不能被继承
// class X : public Seal {}; // ❌| 概念 | 写法 | 含义 |
|---|---|---|
| 普通函数 | void f() | 静态绑定:编译期按指针类型定死 |
| 虚函数 | virtual void f() | 动态绑定:运行期按对象实际类型分发 |
| 纯虚函数 | virtual void f() = 0 | 只定契约不给实现,类变抽象(接口) |
| 重写标记 | override | 让编译器校验确实重写了基类虚函数 |
| 封死 | final | 禁止继承此类 / 禁止再重写此函数 |
⚠ 多态失效的四种情况
① 按值传参/赋值 → 对象切片;② 函数没写 virtual → 静态绑定;③ 在构造/析构函数里调虚函数 → 只到当前层;④ 默认参数是静态绑定的(虚函数的默认参数取指针类型的版本,别给虚函数设默认参数)。11.4 随堂自测
QUIZ 1
运行期多态的分发依据是?
虚函数调用的路径:对象的 vptr → 实际类型的 vtable → 对应槽位的函数。指针声明类型只决定"能调哪些接口",不决定"执行谁的实现"。
QUIZ 2
在基类构造函数中调用虚函数 speak(),会执行哪个版本?
构造基类部分时,对象的"身份"暂时就是基类:vptr 指向基类 vtable,派生类成员还没初始化。若分发到派生版本,会访问未初始化的成员——所以标准规定只到当前层。析构同理。
CHAPTER 12 · 泛型与 STL
模板与泛型编程
一句话总览:模板是「带类型占位符的代码模具」,编译器在你用到它时按具体类型现场冲压出真实代码——写一份逻辑,服务所有类型,且零运行时开销。
🥮
生活化类比
模板是月饼模具:模具上刻着花纹(算法逻辑),但用什么馅料(类型 T)留空。你用豆沙压一个(
模板是月饼模具:模具上刻着花纹(算法逻辑),但用什么馅料(类型 T)留空。你用豆沙压一个(
max<int>),编译器就产出一个「豆沙月饼」(int 版函数);换莲蓉再压一个,又产出一份独立代码。模具本身不能吃(模板不生成代码),压出来的才能吃(实例化才生成)。这和 Java 泛型的「擦除」完全不同——C++ 每个类型都是真材实料的一份新代码。12.1 函数模板
template.cpp
template <typename T> // T 是类型占位符,typename 可换成 class
T myMax(T a, T b) {
return (a > b) ? a : b;
}
myMax(3, 7); // 自动推导 T = int → 生成 int 版
myMax(2.5, 1.5); // 自动推导 T = double → 生成 double 版
myMax<std::string>("ab", "cd"); // 显式指定 T
// myMax(3, 2.5); // ❌ 推导歧义:T 到底是 int 还是 double?
myMax<double>(3, 2.5); // ✓ 显式指定后 int 隐式转 double
// 非类型模板参数:编译期常量也能当参数
template <typename T, size_t N>
size_t countOf(T (&arr)[N]) { return N; } // 自动 deduce 数组长度!
// C++20 概念:给 T 加约束,报错信息从"天书"变人话
template <typename T> requires std::integral<T>
T gcd(T a, T b) { return b == 0 ? a : gcd(b, a % b); }12.2 类模板与实例化过程
classtemplate.cpp
template <typename T>
class Box {
T item;
public:
Box(T v) : item(std::move(v)) {}
T get() const { return item; }
};
Box<int> b1(42); // 编译器生成 Box<int> 类 + 用到的成员函数
Box<std::string> b2("hi"); // 再生成一份独立的 Box<string>
// 模板特化:对某个类型提供"定制版"
template <>
class Box<bool> { // bool 版单独实现(比如按位压缩存储)
unsigned char bits;
public:
Box(bool v) : bits(v) {}
bool get() const { return bits; }
};
// 这就是 vector<bool> 不是普通容器的原因——它是特化版!模板实例化:一份模具,冲压出多份真实代码
实例化发生在编译期:每个用过的类型组合生成一份专属机器码,这就是「泛型不慢」的原因。
⚠ 模板为什么必须放头文件
编译器实例化模板时必须看到完整定义。若定义放 .cpp,其他翻译单元只见声明 → 实例化不了 → 链接报 undefined reference。规则:模板的声明+定义全放头文件(这也是模板库都是 header-only 的原因)。✓ 一句话记住
模板 = 编译期的代码生成器。重载是「手写几个版本」,模板是「给规则让编译器写无限个版本」。STL 整个就是用模板盖起来的大厦。12.3 随堂自测
QUIZ 1
C++ 模板相比 Java 泛型(类型擦除)的本质区别是?
C++ 模板是"代码冲压":vector<int> 和 vector<string> 是两个毫无关系的真实类,各自有最优机器码,零运行期开销;代价是编译慢、体积大。Java 擦除后只有一份代码,装箱/转型有运行期成本。
QUIZ 2
函数模板的定义写在 a.cpp,main.cpp 里调用它,结果通常是?
main.cpp 只看到声明,实例化需要完整定义;a.cpp 有定义但没人以具体类型调用,也不生成。两头都没产出 → 链接器找不到符号。模板定义放头文件即可解决。
CHAPTER 13 · 泛型与 STL
STL 容器:标准库的数据结构兵器谱
一句话总览:vector(动态数组)是默认首选;要按 key 查找用 map/unordered_map;要频繁中间插删用 list;容器选型 = 选对内存结构 = 选对复杂度。
🗄️
生活化类比
vector = 电影院连排座位:找第 i 个座位一步到位(O(1)),但往中间加人全排都得挪。list = 寻宝纸条链:每张纸条写着下一张的位置,插入只需改两张纸条,但找第 100 张必须从头数。map = 按拼音排序的字典:查字稳定 O(log n),还能按序翻页。unordered_map = 快递柜:按手机号哈希直接算出柜号,平均 O(1),但柜子没有顺序。
vector = 电影院连排座位:找第 i 个座位一步到位(O(1)),但往中间加人全排都得挪。list = 寻宝纸条链:每张纸条写着下一张的位置,插入只需改两张纸条,但找第 100 张必须从头数。map = 按拼音排序的字典:查字稳定 O(log n),还能按序翻页。unordered_map = 快递柜:按手机号哈希直接算出柜号,平均 O(1),但柜子没有顺序。
13.1 容器全景与复杂度对照
| 容器 | 底层结构 | 随机访问 | 尾部增删 | 中间插删 | 按值/键查找 | 典型场景 |
|---|---|---|---|---|---|---|
vector | 连续动态数组 | O(1) | 摊还 O(1) | O(n) | O(n) | 默认首选,90% 场景 |
array<T,N> | 定长数组 | O(1) | 不支持 | 不支持 | O(n) | 长度编译期固定 |
deque | 分段连续 | O(1) | 两头 O(1) | O(n) | O(n) | 队列、两头都要增删 |
list | 双向链表 | O(n) | O(1) | 已知位置 O(1) | O(n) | 频繁中间插删+迭代器稳定 |
map / set | 红黑树 | — | — | O(log n) | O(log n) | 需要有序、范围查询 |
unordered_map/set | 哈希表 | — | — | 平均 O(1) | 平均 O(1),最坏 O(n) | 纯查找、不关心顺序 |
四种底层结构长什么样
结构决定复杂度:连续内存→随机访问快;链表→插删快;平衡树→有序稳定;哈希→平均最快但无序。
13.2 vector 深入:size、capacity 与扩容
HANDS-ON DEMO
vector 扩容观察器
连续点击 push_back,观察 capacity 何时翻倍、元素何时「搬家」。搬家 = 旧内存全部失效!
vector.cpp
std::vector<int> v;
v.reserve(1000); // 预留容量:已知规模先 reserve,避免反复搬家
for (int i = 0; i < 1000; ++i) v.push_back(i);
v.size(); // 实际元素数
v.capacity(); // 当前内存能装多少(≥ size)
v[3]; v.at(3); // at 带边界检查
v.front(); v.back();
v.pop_back(); // 删尾部 O(1)
v.erase(v.begin() + 2); // 删中间 O(n),后面元素整体前移
v.clear(); // size=0,但 capacity 不变(内存不还)
v.shrink_to_fit(); // 请求归还多余容量
// ⚠ 扩容/插入会使迭代器、指针、引用失效!
int& r = v[0];
v.push_back(1); // 若触发扩容,r 已悬垂!之后用 r 是 UB13.3 map 与 unordered_map 实战
map.cpp
std::map<std::string, int> scores; // 按 key 字典序自动排序
scores["Tom"] = 90;
scores.insert({"Amy", 85});
scores.emplace("Bob", 77); // 原地构造,少一次拷贝
if (auto it = scores.find("Tom"); it != scores.end()) // C++17 if 初始化
std::cout << it->second; // it->first 是 key,second 是 value
// ⚠ operator[] 的陷阱:key 不存在会"默默插入"默认值!
int x = scores["Nobody"]; // 表里多了一条 {"Nobody", 0}!
// 只查不插:用 find / at(at 找不到抛异常)/ contains(C++20)
std::unordered_map<int, std::string> id2name; // 哈希版:不排序,平均 O(1)
id2name[7] = "肖俊";
for (const auto& [id, name] : id2name) // C++17 结构化绑定
std::cout << id << " -> " << name << '\n';✓ 选型三问
① 只是存一串元素?→ vector(别犹豫)。② 要按 key 查?需要有序/范围查询 → map/set;只要快查 → unordered_map/set。③ 真的频繁在中间插删且已持有位置?→ list。经验法则:元素少于几千个时,vector 遍历往往比花哨结构更快(缓存的威力)。13.4 随堂自测
QUIZ 1
vector 的 push_back 为什么是「摊还 O(1)」而不是每次 O(1)?
容量按约 2 倍增长:n 次 push 中扩容搬移总量约 2n,平均每次 O(1)。若每次只 +1 扩容,总搬移是 O(n²)——倍增是关键设计。
QUIZ 2
std::map<string,int> m; int v = m["ghost"]; 的副作用是?map/unordered_map 的 operator[] 语义是"访问或创建":key 不存在就值初始化插入。只想查询请用 find/at/contains,否则表会越长越大。
CHAPTER 14 · 泛型与 STL
迭代器与算法:STL 的灵魂搭档
一句话总览:迭代器是「统一的遍历遥控器」,把容器和算法解耦;算法通过 [begin, end) 半开区间操作任何容器——学 STL 的核心是学会「用算法代替手写循环」。
📺
生活化类比
迭代器是电视遥控器的「下一个」键:不管电视里放的是电影频道还是体育频道(vector 还是 list),按键行为统一——
迭代器是电视遥控器的「下一个」键:不管电视里放的是电影频道还是体育频道(vector 还是 list),按键行为统一——
++it 换下一个,*it 看当前内容。算法(sort/find)是只认遥控器的自动搜台程序:它不认识任何具体容器,只要给它「起点键」和「终点标志」就能干活。容器随便换,算法一行不改。14.1 半开区间 [begin, end)
end() 不是最后一个元素,而是「最后一个的下一格」
*end() 是未定义行为——end 只是「到此为止」的路标,不是元素。
iterator.cpp
std::vector<int> v{10, 20, 30};
auto it = v.begin(); // it 指向第一个元素
*it; // 10:解引用 = 读当前元素
++it; // 走到下一个
it == v.end(); // 是否已越过末尾
// 迭代器分类(能力从弱到强):
// 输入/输出 → 前向(++) → 双向(++/--) → 随机访问(+n/[]/比较)
// list 是双向迭代器:it + 5 ❌;vector 是随机访问:it + 5 ✓
// sort 需要随机访问迭代器 → std::sort(list.begin(),...) ❌ 用 list.sort()14.2 高频算法速查
algorithm.cpp
#include <algorithm>
#include <numeric>
std::vector<int> v{5, 2, 8, 2, 9};
std::sort(v.begin(), v.end()); // 升序 {2,2,5,8,9}
std::sort(v.begin(), v.end(), std::greater<int>()); // 降序
std::sort(v.begin(), v.end(),
[](int a, int b){ return a > b; }); // 自定义比较(lambda)
auto it = std::find(v.begin(), v.end(), 8); // 线性查找
bool has = it != v.end();
int sum = std::accumulate(v.begin(), v.end(), 0); // 求和
int mx = *std::max_element(v.begin(), v.end()); // 最大值
// 有序容器上二分查找 O(log n)
bool found = std::binary_search(v.begin(), v.end(), 5);
auto lb = std::lower_bound(v.begin(), v.end(), 5); // 第一个 ≥5 的位置
int n = std::count_if(v.begin(), v.end(),
[](int x){ return x % 2 == 0; }); // 数偶数
std::for_each(v.begin(), v.end(), [](int x){ std::cout << x; });
std::transform(v.begin(), v.end(), v.begin(),
[](int x){ return x * x; }); // 每个元素平方(写回原地)
// ⚠ remove 不删元素!只把"留下的"挪到前面,返回新逻辑结尾
v.erase(std::remove(v.begin(), v.end(), 2), v.end()); // erase-remove 惯用法
// C++20 一步到位:std::erase(v, 2);⚠ 迭代器失效:边遍历边删的经典崩溃
for (auto it = v.begin(); it != v.end(); ++it) if (*it==2) v.erase(it); —— erase 后 it 已失效,++it 是 UB。正确姿势:it = v.erase(it);(erase 返回下一个有效迭代器),否则才 ++it;或者干脆用 erase-remove 惯用法。✓ 思维升级
看到「手写 for 循环做统计/查找/变换」,先想有没有现成算法:算法名即意图(count_if 一眼看懂),且经过极致优化、不易写出边界 bug。这是从「会 C++」到「写好 C++」的分水岭。14.3 随堂自测
QUIZ 1
对
std::list 调用 std::sort(l.begin(), l.end()) 会?std::sort 内部要做 it+n、区间折半等随机访问操作,list 迭代器不支持。list 自带成员函数 l.sort()(基于链表归并),用它即可。
QUIZ 2
std::remove(v.begin(), v.end(), 2) 执行后,vector 的 size?
算法只通过迭代器操作元素,无权改变容器大小。remove 把不等于 2 的元素挪到前段,尾部残留旧值。所以标准写法是 v.erase(remove(...), v.end()),C++20 用 std::erase。
CHAPTER 15 · 现代 C++ 进阶
智能指针:让 delete 成为历史
一句话总览:智能指针是「带自动退租协议的堆内存管家」——unique_ptr 独占所有权(零开销首选),shared_ptr 共享计数(最后一个离场者关灯),weak_ptr 只围观不计数(破循环引用)。
🔑
生活化类比
unique_ptr = 独栋房的唯一房主:房产证只有你的名字,不能复印(禁止拷贝),但可以过户(move);你搬走(析构)房子自动拆(delete)。shared_ptr = 合租计数牌:门口挂个计数牌,搬进一人 +1,搬走一人 -1,最后走的人负责关灯锁门(计数归零才 delete)。weak_ptr = 访客登记:知道房子在哪但不算住户、不加计数;进门前先问「房子还在吗」(lock()),避免闯进已拆的房。
unique_ptr = 独栋房的唯一房主:房产证只有你的名字,不能复印(禁止拷贝),但可以过户(move);你搬走(析构)房子自动拆(delete)。shared_ptr = 合租计数牌:门口挂个计数牌,搬进一人 +1,搬走一人 -1,最后走的人负责关灯锁门(计数归零才 delete)。weak_ptr = 访客登记:知道房子在哪但不算住户、不加计数;进门前先问「房子还在吗」(lock()),避免闯进已拆的房。
15.1 三兄弟用法
smart.cpp
#include <memory>
// unique_ptr:独占,离开作用域自动 delete
auto p = std::make_unique<int>(42); // ✓ 工厂函数,别手写 new
std::cout << *p; // 用法和裸指针一样
// auto q = p; // ❌ 禁止拷贝:所有权唯一
auto q = std::move(p); // ✓ 过户:p 变 nullptr,q 接管
// shared_ptr:共享,引用计数归零才释放
auto a = std::make_shared<std::string>("hi"); // 计数 = 1
{
auto b = a; // 计数 = 2(拷贝合法)
std::cout << a.use_count(); // 2
} // b 析构 → 计数 = 1
// a 析构 → 计数 = 0 → delete
// weak_ptr:观察者,不增加计数
std::weak_ptr<std::string> w = a;
if (auto sp = w.lock()) { // 尝试升级成 shared_ptr
std::cout << *sp; // 对象还活着才进这里
} else {
// 对象已被释放,安全得知,不会悬垂
}所有权关系一图流
默认 unique_ptr;确需共享才 shared_ptr;出现「互相持有」立刻想到 weak_ptr。
15.2 循环引用:shared_ptr 唯一的坑
cycle.cpp
struct Node {
std::shared_ptr<Node> next;
std::shared_ptr<Node> prev; // ❌ 双向都 shared → 循环引用
};
auto a = std::make_shared<Node>();
auto b = std::make_shared<Node>();
a->next = b; // b 计数 = 2
b->prev = a; // a 计数 = 2
// 作用域结束:外部 a、b 析构 → 各计数降到 1,永远到不了 0
// 两个对象互相"扶着对方",谁也不释放 → 泄漏!
struct FixedNode {
std::shared_ptr<FixedNode> next; // 拥有方向:父 → 子
std::weak_ptr<FixedNode> prev; // 回指方向:子 ⇢ 父(弱观察)
}; // ✓ 计数链无环,正常释放✓ 所有权设计口诀
「拥有用 shared,回指用 weak」。画出所有权方向图:树形(父拥有子,子弱引用父)永远安全;出现环就把其中一条边改 weak。另外:函数参数不涉及所有权时传裸指针 T* 或引用 T&,别动不动传 shared_ptr(白白做原子计数)。⚠ make_shared 优于 new
shared_ptr<T>(new T) 要两次分配(对象+控制块),且异常场景可能泄漏;make_shared<T>() 一次分配两者相邻,更快更缓存友好。unique_ptr 同理用 make_unique(C++14)。15.3 随堂自测
QUIZ 1
两个对象各持一个指向对方的 shared_ptr,外部引用全部消失后会?
引用计数无法回收环:A 等 B 归零、B 等 A 归零,互相僵持。解法是把回指边改成 weak_ptr。这也是引用计数相对 GC 的根本短板。
QUIZ 2
想把 unique_ptr 的所有权交给另一个变量,正确写法是?
unique_ptr 禁止拷贝、允许移动。move 后 p 变 nullptr,q 独占对象。C 得到裸指针不转移所有权(q 析构不会 delete,p 析构才 delete);release 放弃所有权后需要手动 delete,容易泄漏。
CHAPTER 16 · 现代 C++ 进阶
移动语义:搬走,而不是复印
一句话总览:对「将亡的临时对象」,与其深拷贝它的资源,不如直接把资源指针偷过来(move)——O(n) 拷贝变 O(1) 过户;std::move 只是「我允许你偷」的授权书,本身不搬任何东西。
🏠
生活化类比
你要搬进新家,旧家马上要拆(临时对象将亡)。拷贝 = 把旧家所有家具照着买一套新的放新家——费时费钱。移动 = 直接把旧家具搬过来,旧家只剩空壳。旧家反正要拆,何必买新的?
你要搬进新家,旧家马上要拆(临时对象将亡)。拷贝 = 把旧家所有家具照着买一套新的放新家——费时费钱。移动 = 直接把旧家具搬过来,旧家只剩空壳。旧家反正要拆,何必买新的?
std::move(x) 就是给搬家公司签的授权书:「x 里的东西你随便搬,我不再用它了」。搬家公司(移动构造函数)才是真正干活的。16.1 左值与右值:一眼分辨
value.cpp
int a = 10; // a 是左值:有名字、有住址、之后还要用
int& r = a; // 左值引用:只能绑左值
// int& r2 = 10; // ❌ 10 是右值:临时的、马上消失、没名字
int&& rr = 10; // ✓ 右值引用:专门绑右值(将亡值)
std::string s1 = "hello";
std::string s2 = s1; // 拷贝:s1 之后还要用,必须复印
std::string s3 = std::move(s1); // 移动:授权偷走 s1 的内部缓冲区
// 此刻 s1 处于"有效但未指定"状态:能析构能赋值,别读它的内容
// 典型收益场景:函数返回大对象、容器扩容、临时量入容器
std::vector<std::string> v;
std::string big(1000000, 'x');
v.push_back(std::move(big)); // O(1) 过户指针,而非复制 100 万字符ℹ 判断口诀
「能取地址、还要接着用的 → 左值;马上就死的临时工 → 右值」。字面量、函数返回的临时对象、算术表达式结果都是右值。注意:有名字的右值引用变量本身是左值(rr 有名字),所以转发时要再 std::move 一次。16.2 拷贝 vs 移动:内存视角
string 的拷贝与移动,指针层面发生了什么
vector 扩容时只有 noexcept 的移动构造才会被启用(否则退回拷贝以保证异常安全)——移动构造务必标 noexcept。
16.3 std::move 的真相与使用守则
move_rules.cpp
// std::move 本质:只是 static_cast<T&&>(x),一个类型转换!
// 它不移动任何东西,只是把左值"标记"为可偷窃的右值。
// 真正搬资源的是接收方的移动构造/移动赋值。
std::string f() {
std::string s = "result";
return s; // ✓ 直接返回!NRVO/隐式移动已最优
// return std::move(s); // ❌ 反而可能阻止返回值优化(NRVO),画蛇添足
}
void sink(std::string s); // 按值收参的"水槽函数"
std::string name = "Tom";
sink(name); // 之后还用 name → 拷贝
sink(std::move(name)); // 之后不用 name → 移动,省一次复制
// 完美转发:模板里保持实参的左/右值属性
template <typename T>
void wrapper(T&& arg) { // 万能引用(不是右值引用!)
sink(std::forward<T>(arg)); // 左值进→左值出,右值进→右值出
}⚠ 三条纪律
① move 之后别再读源对象的内容(有效但未指定状态);② return 局部变量别画蛇添足加 move(编译器本来就会优化);③ const 对象 move 不动——const string&& 匹配不了移动构造(偷=修改),会静默退化成拷贝。16.4 随堂自测
QUIZ 1
std::move(x) 本身做了什么?
std::move 是纯编译期的 static_cast<T&&>,一行机器码都不产生。若没有接收方实施移动(比如类型没有移动构造),x 毫发无损——照样走拷贝。
QUIZ 2
为什么移动构造函数应当标记 noexcept?
vector 搬到一半若移动抛异常,旧内存已毁、新内存不全,无法回滚。所以标准库用 move_if_noexcept:不 noexcept 就整体拷贝。不标 noexcept,你的移动优化在容器里全部白写。
CHAPTER 17 · 现代 C++ 进阶
异常处理:错误的高速通道
一句话总览:throw 把错误「直接空投」给上层能处理它的 catch,途中自动析构所有已构造的栈对象(栈展开);配合 RAII,异常路径也能不泄漏任何资源。
🚨
生活化类比
普通返回值报错像层层打报告:科员发现火情→报科长→报处长→…每层都得写「if (出错) return 错误码」,一层偷懒信息就丢了。异常像火警警报:任何楼层按下按钮(throw),警报直达消防控制室(匹配的 catch),中间楼层不用写任何转发代码——但撤离时每层自动落防火门(栈展开析构局部对象),这就是 RAII 兜底。
普通返回值报错像层层打报告:科员发现火情→报科长→报处长→…每层都得写「if (出错) return 错误码」,一层偷懒信息就丢了。异常像火警警报:任何楼层按下按钮(throw),警报直达消防控制室(匹配的 catch),中间楼层不用写任何转发代码——但撤离时每层自动落防火门(栈展开析构局部对象),这就是 RAII 兜底。
17.1 基本用法
exception.cpp
#include <stdexcept>
double divide(double a, double b) {
if (b == 0)
throw std::invalid_argument("除数不能为 0"); // 抛出
return a / b;
}
int main() {
try {
std::cout << divide(10, 0);
} catch (const std::invalid_argument& e) { // 按类型匹配,常引用捕获
std::cout << "参数错误: " << e.what() << '\n';
} catch (const std::exception& e) { // 基类兜底(放最后)
std::cout << "其他标准异常: " << e.what() << '\n';
}
// 没人 catch → std::terminate → 程序中止
}
// 自定义异常:继承 std::exception 家族
class DbError : public std::runtime_error {
public:
DbError(const std::string& msg) : std::runtime_error(msg) {}
};
void cleanup() noexcept; // noexcept:承诺不抛;真抛了直接 terminate
int get() noexcept { return 42; }17.2 栈展开:异常路径上的自动清场
throw 之后,沿途栈对象逐一析构
栈展开只析构「栈对象」。裸指针指向的堆内存不在保护范围——所以资源必须交给 RAII 对象管理。
17.3 异常使用守则
- 按 const 引用捕获:按值捕获会拷贝甚至切片(派生异常被切成基类)。
- catch 顺序从派生到基类:基类放前面会把派生类全吞掉。
- 析构函数绝不抛异常:栈展开中再抛 → 直接 terminate。析构里可能失败的操作要吞掉或记日志。
- 异常用于「异常」:文件不存在、网络断开等意外;正常的业务分支(用户输错密码)用返回值/optional,别拿异常当 goto。
- 构造函数失败只能靠抛异常报告(没有返回值),且此时析构函数不会被调(对象没诞生),已构造的成员会自动析构。
✓ 错误处理选型
可恢复的业务失败 → 返回值 / std::optional / std::expected(C++23);真正的意外 → 异常;程序自身逻辑 bug(不该发生的状态)→ assert / static_assert。性能敏感/嵌入式团队常禁异常,此时统一用错误码 + RAII。17.4 随堂自测
QUIZ 1
异常从 throw 传播到 catch 的过程中,途经函数里已构造的局部对象会?
栈展开保证沿途所有已构造的自动存储期对象按构造逆序析构。这正是「RAII + 异常」能组成异常安全代码的机制基础。
QUIZ 2
为什么析构函数中不能让异常逃逸?
C++ 无法同时传播两个异常。析构函数默认 noexcept,异常逃出即 terminate。析构中的可失败操作(如 flush/close)应 try-catch 吞掉并记日志。
CHAPTER 18 · 现代 C++ 进阶
现代 C++ 特性精华(11/14/17/20)
一句话总览:现代 C++ 的主旋律是「更安全、更简洁、零开销」:auto 推导、lambda 匿名函数、结构化绑定、optional/string_view,每一个都在消灭旧写法的样板代码和坑。
🛠️
生活化类比
老 C++ 像手动挡汽车:离合、挂挡全自己来(手写迭代器类型、new/delete、仿函数类)。现代 C++ 是自动挡 + 辅助驾驶:auto 帮你换挡(类型推导),lambda 是随手叫的代驾(匿名函数),智能指针是自动泊车(资源托管)。车还是那台车(零开销抽象),但你少犯 80% 的操作性错误。
老 C++ 像手动挡汽车:离合、挂挡全自己来(手写迭代器类型、new/delete、仿函数类)。现代 C++ 是自动挡 + 辅助驾驶:auto 帮你换挡(类型推导),lambda 是随手叫的代驾(匿名函数),智能指针是自动泊车(资源托管)。车还是那台车(零开销抽象),但你少犯 80% 的操作性错误。
18.1 版本演进速览
四个关键版本各带来什么
学习顺序建议:吃透 11 → 顺手用 14/17 → 项目允许时上 20。编译器开关:-std=c++17 / c++20。
18.2 lambda:随写随用的匿名函数
lambda.cpp
// 语法:[捕获列表](参数) -> 返回类型 { 函数体 }
int factor = 3;
auto mul = [factor](int x) { return x * factor; }; // 按值捕获 factor
mul(5); // 15
int count = 0;
auto add = [&count](int x) { count += x; }; // 按引用捕获:能改外部
add(4); // count = 4
// 捕获方式速记:
// [ ] 什么都不捕获
// [=] 全部按值拷贝(快照)
// [&] 全部按引用(共享本体)
// [x, &y] x 拷贝,y 引用(推荐精确捕获)
// [x = std::move(big)] 初始化捕获(C++14):把大对象移进 lambda
std::vector<int> v{5, 1, 4, 2};
std::sort(v.begin(), v.end(), [](int a, int b){ return a > b; });
// 泛型 lambda(C++14):参数也能 auto
auto print = [](const auto& x){ std::cout << x; };按值捕获 = 拍快照,按引用捕获 = 共享本体
lambda 本质是编译器生成的匿名类:捕获变量 = 成员变量,operator() = 函数体。值捕获是成员拷贝,引用捕获是成员引用。
18.3 日常高频新特性清单
modern.cpp
// 结构化绑定(C++17):拆包一步到位
std::map<std::string,int> m{{"a",1}};
for (const auto& [key, value] : m) { /* 直接用 key/value */ }
auto [x, y] = std::pair{1, 2};
// if / switch 带初始化(C++17):变量作用域限制在分支内
if (auto it = m.find("a"); it != m.end()) use(it->second);
// optional:可能没有值,替代"返回 -1 表示失败"
std::optional<int> parseInt(std::string_view s) {
if (s.empty()) return std::nullopt; // 没值
return std::stoi(std::string(s));
}
if (auto v = parseInt("42")) use(*v); // 有值才进
int n = parseInt("").value_or(0); // 没值给默认
// string_view(C++17):只读字符串的"窗口",零拷贝传参
void log(std::string_view sv); // string、char*、字面量都能传
// ⚠ view 不拥有内存:别让它活得比原字符串长!
// constexpr 函数:编译期能算就编译期算
constexpr int square(int x) { return x * x; }
static_assert(square(5) == 25); // 编译期验证
int arr[square(3)]; // 编译期常量可当数组长度
// C++20 ranges:算法直接吃容器,还能管道串联
// auto evens = v | std::views::filter([](int x){ return x%2==0; });✓ 现代风格自检清单
① 还看到裸 new/delete?→ 换 make_unique/容器。② 还在手写迭代器类型?→ auto。③ 输出参数指针?→ 返回值 + optional/结构化绑定。④ 仿函数类只为传给算法?→ lambda。⑤ const string& 只读参数?→ string_view 更通用。⑥ 用 NULL 或 0 当空指针?→ nullptr。18.4 随堂自测
QUIZ 1
把按引用捕获局部变量的 lambda 存入 std::function 并在函数返回后调用,会?
引用捕获只是存地址,不延长寿命。lambda 逃逸出作用域(异步回调、存容器)时必须值捕获或初始化捕获 move 进去。这是异步代码的经典崩溃源。
QUIZ 2
std::string_view 最大的风险是?
string_view 只是 {指针, 长度} 的窗口,零拷贝是它的优点也是风险:别返回指向局部 string 的 view,别把临时 string 的 view 存起来。只读、短生命周期传参是它的最佳场景。
CHAPTER 19 · 并发与实战
多线程与并发
一句话总览:多线程让多个执行流同时干活;共享可变数据必须用 mutex 上锁(用 lock_guard 自动管理),否则数据竞争是未定义行为;能不共享就不共享,是并发的第一设计原则。
🚻
生活化类比
线程是同时干活的工人,共享变量是公用记账本。两个工人同时写同一页(数据竞争),账就花了——而且花得随机、难以复现。mutex = 单间厕所的门锁:进去先锁门(lock),别人只能等;出来必须开锁(unlock),否则所有人等到天荒地老(死锁)。lock_guard = 自动门锁:人离开(作用域结束/抛异常)自动开锁,杜绝忘解锁。死锁:A 拿着钥匙 1 等钥匙 2,B 拿着钥匙 2 等钥匙 1——俩人都永远等着。
线程是同时干活的工人,共享变量是公用记账本。两个工人同时写同一页(数据竞争),账就花了——而且花得随机、难以复现。mutex = 单间厕所的门锁:进去先锁门(lock),别人只能等;出来必须开锁(unlock),否则所有人等到天荒地老(死锁)。lock_guard = 自动门锁:人离开(作用域结束/抛异常)自动开锁,杜绝忘解锁。死锁:A 拿着钥匙 1 等钥匙 2,B 拿着钥匙 2 等钥匙 1——俩人都永远等着。
19.1 创建线程与基本同步
thread.cpp
#include <thread>
#include <mutex>
int counter = 0; // 共享变量
std::mutex mtx; // 保护它的锁
void work(int times) {
for (int i = 0; i < times; ++i) {
std::lock_guard<std::mutex> lk(mtx); // 构造即上锁
++counter; // 临界区:同一时刻仅一个线程
} // 析构自动解锁(RAII!)
}
int main() {
std::thread t1(work, 100000);
std::thread t2(work, 100000);
t1.join(); // 等 t1 干完(必须 join 或 detach,否则析构 terminate)
t2.join();
std::cout << counter; // 稳定 200000;不加锁则是随机小于 20 万的数
}
// 原子变量:简单计数不需要锁
std::atomic<int> ac{0};
ac.fetch_add(1); // 硬件级原子操作,无锁
// 更高层:async 拿返回值
auto fut = std::async(std::launch::async, []{ return heavyCompute(); });
int result = fut.get(); // 阻塞等待结果19.2 数据竞争与死锁图解
左:++counter 为什么会丢更新 右:死锁如何形成
数据竞争的后果不是「数字不准」这么简单——它是 UB,可能撕裂任何数据结构。共享可变状态 = 必须同步。
19.3 并发工具箱与守则
| 工具 | 用途 | 要点 |
|---|---|---|
std::thread | 创建执行流 | 析构前必须 join/detach;传引用要 std::ref |
lock_guard / scoped_lock | 自动锁 | RAII,作用域即临界区;scoped_lock 可多锁防死锁 |
unique_lock | 灵活锁 | 可中途 unlock/延迟加锁,配合条件变量 |
std::atomic<T> | 无锁原子量 | 计数/标志位;复杂不变式仍需 mutex |
condition_variable | 等待通知 | wait 必须带谓词(防虚假唤醒):cv.wait(lk,[&]{return ready;}) |
async / future | 任务+取结果 | 比裸 thread 高层,异常也能传回 get() |
⚠ 并发四大坑
① 忘 join → terminate;② 给线程传局部变量引用而线程活得比变量长 → 悬垂;③ 手写 lock/unlock 中途 return/异常忘解锁 → 死锁(永远用 RAII 锁);④ 两把锁顺序不一致 → 死锁(固定顺序或 scoped_lock)。✓ 并发设计第一原则
「最好的同步是不需要同步」:优先各线程独立数据、最后汇总(分治);或不可变数据共享;实在要共享可变状态,把锁的粒度缩到最小、持有时间缩到最短。调试工具:ThreadSanitizer(-fsanitize=thread)。19.4 随堂自测
QUIZ 1
两个线程各对共享 int 做 10 万次 ++(无锁),最终结果通常?
++ 是读-改-写三步,交错执行会互相覆盖。加 mutex 或改 std::atomic 才能稳定 200000。注意结果不是"少一点"而是 UB——优化器可能做出任何事。
QUIZ 2
预防「两把锁交叉等待」死锁,最直接的手段是?
死锁四条件里的"循环等待"最好打破:全局统一锁序,或交给 scoped_lock 的死锁避免算法。sleep 只是碰运气,atomic 不能保护多变量不变式,detach 与死锁无关。
CHAPTER 20 · 并发与实战
陷阱总表与学习路线
一句话总览:C++ 的强大以「信任程序员」为代价——未定义行为(UB)是头号敌人;背下高频陷阱清单、坚持现代风格、用好检测工具,再把路线走完,你就是可靠的 C++ 开发者。
🧗
生活化类比
C++ 像专业登山装备:给你最大的自由和性能,但不装护栏。UB 就是「踩空」——不是每次都摔(有时看似正常),但一旦摔就是重伤(随机崩溃、数据损坏、安全漏洞)。Sanitizer 是安全绳:训练(测试)时全程系上,踩空立刻报警定位,而不是带病上线。
C++ 像专业登山装备:给你最大的自由和性能,但不装护栏。UB 就是「踩空」——不是每次都摔(有时看似正常),但一旦摔就是重伤(随机崩溃、数据损坏、安全漏洞)。Sanitizer 是安全绳:训练(测试)时全程系上,踩空立刻报警定位,而不是带病上线。
20.1 高频 UB / 陷阱总表(收藏级)
| # | 陷阱 | 后果 | 正确姿势 |
|---|---|---|---|
| 1 | 局部变量未初始化就使用 | 随机值 / UB | int n{}; 声明即初始化 |
| 2 | 数组/vector 下标越界 | UB,静默破坏内存 | 范围 for / .at() / 检查 size |
| 3 | 返回局部变量的引用/指针 | 悬垂,读垃圾 | 值返回(有 RVO 不慢) |
| 4 | 解引用空/野/悬垂指针 | 崩溃或更糟 | 初始化 nullptr、判空、智能指针 |
| 5 | new[] 配 delete / 重复 delete | UB | 配对;干脆 make_unique |
| 6 | 有符号整数溢出 | UB(编译器可假设不发生) | 先检查范围或用更大类型 |
| 7 | unsigned 与负数混算 | 回绕成天文数字 | 统一用有符号或先转型 |
| 8 | 浮点 == 判等 | 精度误差判错 | 误差范围比较;钱用整数分 |
| 9 | 浅拷贝含资源的类 | double free | 深拷贝三/五法则,或零法则 |
| 10 | 基类析构非 virtual | 派生部分泄漏 | 多态基类一律虚析构 |
| 11 | 按值传多态对象(切片) | 多态失效 | 指针/引用传递 |
| 12 | vector 扩容后用旧引用/迭代器 | 悬垂 | reserve 预留;扩容后重取 |
| 13 | 边遍历边 erase | 迭代器失效 UB | it = v.erase(it) 或 erase-remove |
| 14 | map 的 [] 查询不存在的 key | 默默插入 | find / at / contains |
| 15 | lambda 引用捕获后逃逸作用域 | 悬垂 | 值捕获 / 初始化捕获 move |
| 16 | shared_ptr 循环引用 | 永不释放 | 回指边改 weak_ptr |
| 17 | move 后继续读源对象 | 读到未指定值 | move 即放弃,只可析构/重赋值 |
| 18 | 多线程无锁共享写 | 数据竞争 UB | mutex/atomic,或不共享 |
| 19 | thread 忘 join/detach | terminate | join;C++20 用 jthread |
| 20 | 同一表达式多次修改同一变量 | UB,如 i = i++ + 1 | 拆成多条语句 |
20.2 现代 C++ 十条军规
- 零法则优先:成员用 string/vector/智能指针,不手写资源管理。
- 不出现裸 new/delete:make_unique / make_shared / 容器。
- 声明即初始化,优先 {} 列表初始化。
- 能 const 就 const:变量、成员函数、引用参数。
- 大对象传 const& 或 string_view,要修改传 &,小类型传值。
- 算法优于手写循环,lambda 优于仿函数类。
- 多态基类虚析构 + override 标记。
- RAII 管一切资源:内存、文件、锁、连接。
- 开满警告当错误:-Wall -Wextra -Wpedantic(MSVC /W4)。
- 测试全程系安全绳:ASan + UBSan,多线程加 TSan。
debug.sh
# 调试构建三件套(GCC/Clang)
g++ -std=c++17 -Wall -Wextra -g -fsanitize=address,undefined main.cpp -o app
./app # 越界/use-after-free/泄漏/UB 当场报错并给出精确栈
# 多线程数据竞争检测(与 ASan 互斥,单独构建)
g++ -std=c++17 -g -fsanitize=thread main.cpp -o app_tsan20.3 学习路线图
从入门到能干活:四阶段路线
配合工具站:cppreference.com(权威手册)、godbolt.org(在线看汇编)、cplusplus 练习题。学 C++ 最快的路是「写 + 崩 + 查」循环。
20.4 毕业自测
QUIZ 1
关于未定义行为(UB),正确的理解是?
UB 的可怕在于不确定性:Release 优化可能基于"UB 不会发生"的假设重排/删除代码,产生匪夷所思的行为。测试没崩 ≠ 没有 UB,所以要用 ASan/UBSan 主动抓。
QUIZ 2
一个类的所有成员都是 string、vector、unique_ptr,需要手写析构/拷贝/移动吗?
零法则是现代 C++ 的最高境界:把资源管理委托给已经写对的 RAII 类型。含 unique_ptr 的类默认不可拷贝但可移动——语义恰好正确。你一行特殊成员函数都不用写。