罗罗编程学习记录 全栈面试题库
本页导航 展开查看

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 单例

自测题:

  1. 进程地址空间从低到高有哪些区域?堆和栈分别往哪个方向增长?
    • 要点:代码段、全局数据、堆(向上)、内存映射、栈(向下)。
  2. unique_ptr、shared_ptr、weak_ptr 的区别与适用场景?
    • 要点:unique 独占零开销;shared 共享引用计数;weak 观察不拥有,打破循环。
  3. Rule of Five 是哪五个?为什么需要它们?
    • 要点:析构、拷贝构造、拷贝赋值、移动构造、移动赋值;管理资源的类必须正确处理拷贝与移动。
  4. std::move 做了什么?移动后原对象还能用吗?
    • 要点:只转右值引用,不移动;原对象处于有效但未指定状态,不要再读。
  5. 常见 UB 有哪些?为什么 Debug 跑通 Release 会崩?
    • 要点:空指针、越界、use-after-free、未初始化、有符号溢出;Release 优化会放大 UB。
  6. 对象切片是什么?怎么避免?
    • 要点:派生类对象赋值给基类对象时派生部分被切掉;容器存 unique_ptr<Base>。