14.3 阶段 2 内存管理与对象生命周期
所属:全栈开发面试题库 / 学习路径 / 14 C++ 与系统开发
本页目录
一、阶段定位
本阶段是 C++ 与其他语言最本质的分界线。Java 有 GC、Go 有逃逸分析,C++ 没有——你必须自己管对象什么时候创建、什么时候销毁、谁拥有所有权。学不好这一阶段,后面写多线程(阶段 4)会出数据竞争,写服务端(阶段 7)会出内存泄漏与悬垂指针。
不掌握本阶段会在后面具体卡在哪:
- 程序偶尔段错误,GDB 打出栈看到
free()或operator new里崩,你不知道是 double free、还是 use-after-free。 - 用
std::shared_ptr到处传,最后内存只增不减,用 ASan 一查是循环引用。 - 写一个类时不知道要不要写拷贝构造、移动构造、析构函数,被面试官问 Rule of Five 答不上来。
- 函数返回一个大对象,你以为有 RVO 不会拷贝,实际因为写法错误触发了深拷贝,性能差一倍。
判断自己卡住的标志:(1) 让你说出栈对象、堆对象、静态对象的生命周期时机,你只能说"new 在堆、局部在栈";(2) 给你一段 new/delete 配对的代码,你找不到哪里漏 delete;(3) 看到 std::unique_ptr<T> 不知道它能不能拷贝。出现任一现象,先把本阶段六个模块过一遍再进 阶段 3 STL 与泛型编程。
二、阶段目标与投入
| 能力目标(可验证的行为) | 验证方式 |
|---|---|
| 能画出一个进程的内存布局(代码段、全局数据、堆、栈、内存映射) | 纸上画图并解释各区域增长方向 |
| 能区分栈对象、堆对象、静态对象、临时对象的生命周期 | 给一段代码,标注每个对象何时构造何时析构 |
能正确使用 std::unique_ptr 与 std::shared_ptr,避免循环引用 |
用 ASan 验证无泄漏、无 double free |
| 能为一个类写出 Rule of Five(析构、拷贝构造、拷贝赋值、移动构造、移动赋值) | 编译通过,测试深拷贝与移动语义 |
| 能识别未定义行为(UB):空指针解引用、越界、use-after-free、数据竞争 | 用 ASan/UBSan 跑出 UB 报告 |
能说明 RAII 与智能指针的关系,不再手写 new/delete |
代码中不再出现裸 new/delete |
建议学时:
- 全职(每天 4–6 小时):3 周,约 50–60 小时。其中内存布局 8 小时、RAII 与智能指针 16 小时、Rule of Five 与移动语义 16 小时、未定义行为 10 小时、ASan 实战 6 小时、练习 10 小时。
- 在职(每天 2 小时、周末补 4 小时):5–6 周,约 60 小时。写过 C 的人不要跳过——C 的
malloc/free与 C++ 的智能指针思维完全不同。
学时分配:内存布局 15%、智能指针 30%、Rule of Five 与移动 25%、UB 与 ASan 20%、练习 10%。
三、先修自检
| 先修项 | 合格标准 | 不合格时怎么办 |
|---|---|---|
| 阶段 1 语法 | 能写类、构造函数、析构函数、引用 | 回到 阶段 1 |
| 指针概念 | 理解 *、&、nullptr、指针运算 |
写几个 C 风格小程序练手 |
| GDB 基础 | 能用 bt、print、break |
回到 阶段 0 |
| 其他语言经验 | 用过 Java/Go 的 GC 或 Python 的内存管理 | 能说出"GC 帮你做了什么" |
四、知识地图
| 模块 | 知识点 | 掌握程度 | 对应题库章节 |
|---|---|---|---|
| 内存布局 | 代码段、全局数据 BSS、堆、栈、内存映射;增长方向 | 能讲清原理 | 04.9.1 指针内存布局与 RAII |
| 对象生命周期 | 构造时机、析构时机、临时对象生命周期、静态对象 | 能讲清原理 | 04.9.1 指针内存布局与 RAII |
| 智能指针 | unique_ptr、shared_ptr、weak_ptr、make_unique、make_shared |
能讲清原理 | 04.9.1 指针内存布局与 RAII |
| Rule of Five | 析构、拷贝构造、拷贝赋值、移动构造、移动赋值 | 能讲清原理 | 04.9.1 指针内存布局与 RAII |
| 移动语义 | std::move、移动构造、移动赋值、RVO/NRVO |
会用 | 04.9.1 指针内存布局与 RAII |
| 未定义行为 | 空指针、越界、use-after-free、double free、数据竞争、未初始化读取 | 能讲清原理 | 04.9.5 性能优化与工具链 |
| 工具 | ASan、UBSan、valgrind(可选) | 会用 | 04.9.5 性能优化与工具链 |
五、分模块精讲
5.1 进程内存布局与对象生命周期
为什么需要它:C++ 程序崩溃 80% 是内存问题。不知道对象在哪块内存、什么时候销毁,就解释不了段错误、泄漏、悬垂指针。
核心机制:
- 进程地址空间从低到高:代码段(
.text)→ 全局数据段(.data已初始化、.bss未初始化)→ 堆(new/malloc申请,向上增长)→ 内存映射区(动态库、mmap)→ 栈(函数局部变量,向下增长)。 - 栈对象:函数内局部变量,离开作用域自动析构。
- 堆对象:
new申请,需要delete释放;用智能指针管理。 - 静态对象:全局变量或
static局部变量,程序启动时构造、退出时析构。 - 临时对象:表达式返回的右值,在完整表达式结束时析构。
- 对象构造顺序:基类 → 成员 → 派生类构造函数体;析构顺序相反。
最小可运行示例:
#include <iostream>
#include <string>
struct Demo {
std::string name;
explicit Demo(std::string n) : name(std::move(n)) {
std::cout << "ctor: " << name << "\n";
}
~Demo() { std::cout << "dtor: " << name << "\n"; }
};
Demo g_global("global"); // main 之前构造
int main() {
std::cout << "main enter\n";
Demo stack_obj("stack"); // 栈对象
auto* heap_obj = new Demo("heap"); // 堆对象
delete heap_obj; // 手动释放
static Demo static_obj("static"); // 第一次进入时构造
std::cout << "main leave\n";
// stack_obj 在此自动析构
// static_obj 在程序退出时析构
// g_global 在程序退出时析构
return 0;
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
段错误在 main return 后 |
静态对象析构顺序问题 | 避免跨静态对象依赖,或用 nifty counter |
| 栈溢出 | 递归过深或栈对象太大 | 大对象改堆分配或智能指针 |
| 访问已析构对象 | 函数返回局部对象指针/引用 | 不要返回局部对象地址 |
5.2 RAII 与智能指针
为什么需要它:裸 new/delete 配对靠人记,一定会漏。智能指针把"释放"绑到栈对象析构上,即使异常也不漏。
核心机制:
std::unique_ptr<T>:独占所有权,不能拷贝只能移动;零开销,大小与裸指针相同。std::shared_ptr<T>:共享所有权,引用计数控制析构;有原子引用计数开销。std::weak_ptr<T>:不拥有对象,只观察shared_ptr,用于打破循环引用。std::make_unique<T>(args)(C++14)、std::make_shared<T>(args):优先用这两个,异常安全且减少一次分配。- 选择经验:默认用
unique_ptr;需要共享时才用shared_ptr;shared_ptr成员可能互相引用时用weak_ptr打破循环。
最小可运行示例:
#include <iostream>
#include <memory>
struct Node {
int value;
std::shared_ptr<Node> next;
std::weak_ptr<Node> prev; // 用 weak_ptr 打破循环引用
explicit Node(int v) : value(v) {}
};
int main() {
auto head = std::make_shared<Node>(1);
auto tail = std::make_shared<Node>(2);
head->next = tail;
tail->prev = head; // weak_ptr,不增加引用计数
// 离开作用域时两个 shared_ptr 正常析构,无泄漏
return 0;
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 内存只增不减 | shared_ptr 循环引用 |
一方改 weak_ptr |
unique_ptr 拷贝编译失败 |
独占所有权不能拷贝 | 用 std::move 转移 |
从 unique_ptr 取裸指针后存下来 |
智能指针析构后裸指针悬垂 | 只在智能指针存活期间用裸指针,不要长期持有 |
5.3 Rule of Five 与移动语义
为什么需要它:当你写一个管理资源的类(如自己实现的 string、buffer),必须正确处理拷贝与移动,否则要么深拷贝性能差,要么 double free。
核心机制:
- Rule of Five:如果显式声明了析构函数,就要同时声明拷贝构造、拷贝赋值、移动构造、移动赋值,或全部
=default/=delete。 - 拷贝构造:
T(const T& other),深拷贝资源。 - 拷贝赋值:
T& operator=(const T& other),处理自赋值与旧资源释放。 - 移动构造:
T(T&& other),窃取 other 的资源,other 置空。 - 移动赋值:
T& operator=(T&& other)。 std::move不移动任何东西,只是把参数转成右值引用,让编译器选择移动构造而非拷贝构造。- RVO(返回值优化)/NRVO:编译器自动消除返回临时对象的拷贝,现代 C++ 默认开启。
最小可运行示例:
#include <cstring>
#include <iostream>
#include <utility>
class Buffer {
size_t size_ = 0;
char* data_ = nullptr;
public:
explicit Buffer(size_t n) : size_(n), data_(new char[n]) {}
// 析构
~Buffer() { delete[] data_; }
// 拷贝构造(深拷贝)
Buffer(const Buffer& other) : size_(other.size_), data_(new char[other.size_]) {
std::memcpy(data_, other.data_, size_);
}
// 拷贝赋值
Buffer& operator=(const Buffer& other) {
if (this == &other) return *this;
delete[] data_;
size_ = other.size_;
data_ = new char[size_];
std::memcpy(data_, other.data_, size_);
return *this;
}
// 移动构造
Buffer(Buffer&& other) noexcept : size_(other.size_), data_(other.data_) {
other.size_ = 0;
other.data_ = nullptr;
}
// 移动赋值
Buffer& operator=(Buffer&& other) noexcept {
if (this == &other) return *this;
delete[] data_;
size_ = other.size_;
data_ = other.data_;
other.size_ = 0;
other.data_ = nullptr;
return *this;
}
size_t size() const { return size_; }
};
int main() {
Buffer a(1024);
Buffer b = a; // 拷贝构造,深拷贝
Buffer c = std::move(a); // 移动构造,a 此后为空
std::cout << "b size=" << b.size() << ", c size=" << c.size() << "\n";
return 0;
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| double free 段错误 | 手写拷贝构造只拷指针不拷数据 | 深拷贝资源 |
| 移动后对象还在用 | 移动后 other 资源已置空 | 移动后不要再读 other |
std::move 了 const 对象 |
const 对象无法移动,退化拷贝 | 不要对 const 对象 move |
5.4 未定义行为(UB)与 ASan
为什么需要它:C++ 标准规定某些行为是 UB——编译器不保证正确,可能今天跑通明天崩,也可能在 Release 优化下跑出诡异结果。UB 是 C++ 生产事故的最大根因。
核心机制:
- 常见 UB:空指针解引用、越界访问数组、use-after-free、double free、未初始化变量读取、有符号整数溢出、数据竞争、在
const对象上const_cast修改。 - UB 不是"会崩",而是"编译器有权做任何事"。
- ASan(AddressSanitizer):编译时加
-fsanitize=address,运行时检测越界、use-after-free、泄漏。 - UBSan(UndefinedBehaviorSanitizer):加
-fsanitize=undefined,检测整数溢出、对齐错误、空指针解引用等。 - TSan(ThreadSanitizer):阶段 4 用,检测数据竞争。
最小可运行示例:
# 用 ASan 编译
g++ -g -O0 -fsanitize=address,undefined demo.cpp -o demo_asan
./demo_asan
# 输出会直接指出:ERROR: AddressSanitizer: heap-use-after-free
# 并给出分配与释放的调用栈
// demo.cpp:故意制造 UB
#include <memory>
int main() {
int* p = new int(42);
delete p;
*p = 0; // use-after-free,UB
return 0;
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| Debug 跑通、Release 崩 | 未初始化变量或有符号溢出 | 用 UBSan 跑 Debug 版本 |
| 偶发段错误无法复现 | use-after-free 在内存布局变化后表现不同 | ASan 下复现 |
| 程序越跑越慢或内存涨 | 内存泄漏 | ASan 泄漏报告 |
5.5 栈对象、堆对象与容器内存
为什么需要它:STL 容器(vector、string)内部都在堆上分配。理解对象生命周期,才能正确选择"值语义"还是"指针语义"。
核心机制:
- 容器存值:
std::vector<Buffer>存对象本身,拷贝/移动发生在容器内。 - 容器存指针:
std::vector<std::unique_ptr<Base>>存多态对象,避免对象切片。 - 对象切片:把派生类对象赋值给基类对象时,派生类部分被切掉,多态失效。
- 容器扩容:
vector扩容时会移动/拷贝所有元素,大对象用vector<unique_ptr<T>>避免移动开销。
最小可运行示例:
#include <iostream>
#include <memory>
#include <vector>
class Shape {
public:
virtual ~Shape() = default;
virtual void draw() const { std::cout << "shape\n"; }
};
class Circle : public Shape {
public:
void draw() const override { std::cout << "circle\n"; }
};
int main() {
// 错误:对象切片,vector<Shape> 会把 Circle 切成 Shape
// std::vector<Shape> bad; bad.push_back(Circle());
// 正确:存 unique_ptr 多态
std::vector<std::unique_ptr<Shape>> shapes;
shapes.push_back(std::make_unique<Circle>());
for (const auto& s : shapes) s->draw(); // circle
return 0;
}
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 多态失效,调用的是基类方法 | 容器存值导致对象切片 | 容器存 unique_ptr<Base> |
| vector push_back 大对象慢 | 每次扩容拷贝所有元素 | 预分配 reserve(),或存指针 |
5.6 静态对象与单例的生命周期陷阱
为什么需要它:C++ 全局对象初始化顺序跨编译单元未定义,单例在析构时互相调用会崩。
核心机制:
- 跨编译单元的静态对象初始化顺序未定义("static initialization order fiasco")。
- 函数内
static局部变量:C++11 起线程安全初始化,首次进入函数时构造。 - 单例析构顺序:程序退出时静态对象按构造逆序析构;如果 A 的析构访问 B,B 可能已析构。
- 解决:用函数内 static(Meyers 单例),避免跨静态对象依赖;或用
std::weak_ptr+ 后台线程。
最小可运行示例:
// Meyers 单例:线程安全,惰性初始化
class Config {
public:
static Config& instance() {
static Config inst; // C++11 起线程安全初始化
return inst;
}
Config(const Config&) = delete;
Config& operator=(const Config&) = delete;
private:
Config() = default;
};
常见坑:
| 现象 | 原因 | 修法 |
|---|---|---|
| 程序退出时段错误 | 静态对象析构顺序问题 | 用 Meyers 单例,避免跨静态依赖 |
| 多线程首次调用单例崩溃 | C++03 之前非线程安全 | 用 C++11 函数内 static,编译器保证 |
六、分层练习
6.1 复现型
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 生命周期标注 | 给一段含全局、静态、栈、堆对象的代码,标注构造析构顺序 | 10 个对象顺序全对 | 2 小时 |
| unique_ptr 管理 | 把一段裸 new/delete 改成 unique_ptr |
ASan 报告 0 泄漏 | 1 小时 |
| shared_ptr 循环引用 | 写两个互相持有的类,用 weak_ptr 打破 |
ASan 报告 0 泄漏 | 2 小时 |
| ASan 跑 UB | 故意写 use-after-free,用 ASan 复现 | ASan 报告准确指出位置 | 1 小时 |
| Rule of Five 实现 | 为 Buffer 类实现五个成员 |
拷贝深拷贝、移动窃取资源 | 3 小时 |
6.2 改造型
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 消除深拷贝 | 给一个频繁传大对象的函数,改值传为 const& 或移动 |
性能提升,行为不变 | 2 小时 |
| 修循环引用 | 给一段 shared_ptr 循环引用代码,改成 weak_ptr |
内存正常释放 | 2 小时 |
| UBSan 修溢出 | 故意写有符号溢出,用 UBSan 定位并修复 | 0 UB 报告 | 1 小时 |
| 容器存指针 | 把 vector<Base> 改成 vector<unique_ptr<Base>>,修复对象切片 |
多态调用正确 | 2 小时 |
6.3 设计型
| 练习 | 要求 | 验收标准 | 预计耗时 |
|---|---|---|---|
| 设计内存池 | 写一个简单的定长对象池,避免频繁 new/delete | ASan 0 泄漏,性能对比 | 4 小时 |
| 选型对比 | 为"配置缓存"场景比较 unique_ptr、shared_ptr、weak_ptr 三种所有权 |
能说清各自适用场景 | 2 小时 |
| 整理 UB 清单 | 列出 15 种常见 UB 及触发代码 | 每种都有最小复现 | 2 小时 |
七、排障表
| 现象 | 可能原因 | 排查步骤 | 解决办法 |
|---|---|---|---|
| 段错误在 free() 里 | double free 或堆破坏 | ASan 跑复现 | 用智能指针,不手动 delete |
| 偶发段错误 | use-after-free | ASan 下复现 | 修复悬垂指针 |
| 内存只增不减 | 内存泄漏或 shared_ptr 循环引用 | ASan 泄漏报告 / 打印引用计数 | 用 weak_ptr 打破循环 |
| Debug 跑通 Release 崩 | 未初始化变量或 UB | UBSan 跑 Debug | 修复 UB |
| 多态调用失效 | 对象切片 | 看容器类型 | 容器存 unique_ptr<Base> |
| 程序退出时崩溃 | 静态对象析构顺序 | 看崩溃栈 | 用 Meyers 单例,避免跨静态依赖 |
| vector push_back 慢 | 扩容拷贝大对象 | 看 push 次数 | reserve 预分配或存指针 |
| 未初始化变量值诡异 | UB 未定义 | 加 -Wuninitialized 与 UBSan |
初始化所有成员 |
八、出口条件
全部勾选后进入 阶段 3 STL 与泛型编程。
- [ ] 能画出进程内存布局并解释各区域职责
- [ ] 能区分栈、堆、静态、临时对象的生命周期时机
- [ ] 能正确使用
unique_ptr、shared_ptr、weak_ptr,避免循环引用 - [ ] 能为资源管理类写出 Rule of Five
- [ ] 能识别常见 UB 并用 ASan/UBSan 复现
- [ ] 能说明对象切片与多态失效原因
- [ ] 能解释静态对象初始化顺序问题与 Meyers 单例
自测题:
- 进程地址空间从低到高有哪些区域?堆和栈分别往哪个方向增长?
- 要点:代码段、全局数据、堆(向上)、内存映射、栈(向下)。
unique_ptr、shared_ptr、weak_ptr的区别与适用场景?- 要点:unique 独占零开销;shared 共享引用计数;weak 观察不拥有,打破循环。
- Rule of Five 是哪五个?为什么需要它们?
- 要点:析构、拷贝构造、拷贝赋值、移动构造、移动赋值;管理资源的类必须正确处理拷贝与移动。
std::move做了什么?移动后原对象还能用吗?- 要点:只转右值引用,不移动;原对象处于有效但未指定状态,不要再读。
- 常见 UB 有哪些?为什么 Debug 跑通 Release 会崩?
- 要点:空指针、越界、use-after-free、未初始化、有符号溢出;Release 优化会放大 UB。
- 对象切片是什么?怎么避免?
- 要点:派生类对象赋值给基类对象时派生部分被切掉;容器存
unique_ptr<Base>。
- 要点:派生类对象赋值给基类对象时派生部分被切掉;容器存