Scl's CS Wiki

Appearance

C++ 现代内存管理：智能指针详解 ​

零、 前置知识：内存泄漏与危害 ​

内存泄漏是指你向系统申请分配内存进行使用（new/malloc），然后系统在堆内存中给这个对象申请一块内存空间，但当我们使用完了却没有归还给系统（delete），导致这个不使用的对象一直占据内存单元，造成系统将不能再把它分配给需要的程序。一次内存泄漏的危害可以忽略不计，但是内存泄漏堆积则后果很严重，无论多少内存，迟早会被占完，造成内存泄漏。

引起内存泄漏的原因：

  • 分配给程序的内存忘记回收；

  • 程序代码有问题，造成系统没有办法回收；

  • 某些 API 函数操作不正确，造成内存泄漏；

内存泄露的危害：

  • 频繁 GC（垃圾回收）： 系统分配给每个应用的内存资源都是有限的，内存泄漏导致其他组件可用的内存变少后，一方面会使得 GC 的频率加剧，再发生 GC 的时候，所有进程都必须等待，GC 的频率越高，用户越容易感应到卡顿。另一方面内存变少，可能使得系统额外分配给该对象一些内存，而影响整个系统的运行情况。

  • 导致程序运行崩溃： 一旦内存不足以为某些对象分配所需要的空间，将会导致程序崩溃，造成体验差。

一、 std::unique_ptr —— 独占型（单身狗） ​

这是现代 C++ 中最推荐、最常用的智能指针。

  • 核心机制： 绝对的独占权。同一时刻，只能有一个 unique_ptr 指向那块内存。

  • 底层原理： 它的源码里直接删除了“拷贝构造函数”和“赋值运算符”（= delete）。

  • 性能： 几乎拥有和原生指针一模一样的极速性能（零开销），因为它内部不需要维护任何额外的计数器。

cpp
unique_ptr<int> p1 = make_unique<int>(10);
unique_ptr<int> p2 = p1; // ❌ 编译直接报错！不准脚踏两条船！

// 如果非要转移所有权，必须用 std::move() 强行“抢”过来：
unique_ptr<int> p3 = std::move(p1); // ✅ p3 接管内存，p1 变成空指针(nullptr)

1. 什么是“拷贝构造函数”和“赋值运算符”？它们有啥用？ ​

在 C++ 里，当你定义了一个变量（比如一个类对象），系统默认允许你把它**“复制”**一份给别人。

  • 拷贝构造函数（Copy Constructor）：

    • 场景： 在新建一个对象的时候，拿一个已经存在的同类对象来给它“抄作业”。

    • 代码长这样：

      cpp
      A obj1;         // 诞生了 obj1
A obj2 = obj1;  // 在新建 obj2 的这一刻，直接照抄 obj1。这就触发了“拷贝构造函数”

  • 赋值运算符（Assignment Operator）：

    • 场景： 两个对象都已经各自出生了，然后把其中一个对象的内容，强行覆盖给另一个。

    • 代码长这样：

      cpp
      A obj1;
A obj2;         // obj1 和 obj2 都已经存在了
obj2 = obj1;    // 把 obj1 的内容强行赋值给 obj2。这就触发了“赋值运算符”

默认情况下的致命危机（浅拷贝）： 如果 obj1 只是个普通的整数 int，抄一份当然没问题。但如果 obj1 内部包含一个指向堆内存（new 出来的蛋糕）的指针，默认的“抄作业”就只会把指针（钥匙）抄过去，而不会去复制那块内存（蛋糕）。

结果就是：obj1 和 obj2 手里拿着一模一样的钥匙，指着同一块蛋糕。当它们各自生命周期结束，调用析构函数去 delete 内存时，同一块蛋糕会被切两次（Double Free），程序当场崩溃。

2. 为什么删除了它俩，就拥有了“绝对的独占权”？ ​

为了防止上面那种“两个人拿着同一把钥匙去开同一扇门”的灾难，C++ 官方在设计 std::unique_ptr 时，做了一个极其霸道的决定：直接在源码级别，把“抄作业”的功能给没收了！

在 unique_ptr 的底层源码里，有这么两行代码（末尾的 = delete 就是“禁用”的意思）：

cpp
// 禁用拷贝构造
unique_ptr(const unique_ptr&) = delete; 
// 禁用赋值运算符
unique_ptr& operator=(const unique_ptr&) = delete;

这就引出了“绝对独占权”的真面目：因为你无法复制它，也无法赋值它。这意味着，只要 unique_ptr 指向了一块内存，全天下就绝对不可能有第二个 unique_ptr 能通过“抄作业”的方式拿到这块内存的地址。它成了这块内存唯一、绝对、排他的合法主人。

TIP

举个现实的例子： unique_ptr 就像是一把无法被配钥匙的顶级防盗门钥匙。你手里有这把钥匙（指针），这套房子（堆内存）就归你独占。别人想找你要个备用钥匙？编译器直接报错：“不准配钥匙（= delete）！”

3. unique_ptr 通常用在什么地方？ ​

既然它这么霸道不能分享，它的核心价值在于**“极度安全且无开销的局部资源管理”**。

  • 场景 1：函数内部的局部对象（防止中途异常导致内存泄漏）

    这是写后端代码最常用的场景。假设你要在函数里处理一张图片：

    cpp
    void processImage() {
    // 传统写法（极度危险）：
    Image* img = new Image("test.jpg");
    // 如果下面这行代码抛出了异常，函数直接中断，最后的 delete 就执行不到了！
    doSomething(img); 
    delete img; 
}

void processImageSafe() {
    // 现代 C++ 写法（完美安全）：
    std::unique_ptr<Image> img = std::make_unique<Image>("test.jpg");
    doSomething(img.get());
    // 哪怕 doSomething 崩溃抛出异常，img 在离开这个大括号时，
    // 作为独占主人的它，绝对会自动带走这块内存，绝不泄漏！
}

  • 场景 2：工厂模式返回生成的对象

    当你写一个函数用来“生产”一个对象时，返回 unique_ptr 是最好的选择。意思是：“我把这个新做好的对象交给你了，以后它的死活全由你负责，我不管了。”

4. 如果非要交出独占权怎么办？（移动所有权） ​

房子不能配备用钥匙，但我如果想把房子卖给你呢？既然不能“复制（Copy）”，C++ 提供了一种极其精妙的机制叫**“移动（Move）”**。如果你非要把 unique_ptr 里的资源交给别人，必须使用 std::move() 强行转移所有权：

CPP
std::unique_ptr<int> p1 = std::make_unique<int>(100);
// std::unique_ptr<int> p2 = p1; // ❌ 编译失败！不能拷贝（不能配备用钥匙）
std::unique_ptr<int> p3 = std::move(p1); // ✅ 成功！转移所有权（过户房子）
// 此时，p3 成了独占的新主人。而 p1 被强行剥夺了钥匙，变成了空指针（nullptr）。

5. 进阶特性与技巧 ​

  • 动态数组的特化版本 unique_ptr<T[]>：

    如果用普通的 unique_ptr 指向数组，默认只会调用 delete，导致只有第一个元素被析构。《C++ Primer》指出，标准库提供了特化版本，加上 [] 后内部会自动使用 delete[]，且支持下标访问。

    CPP
    // ❌ 错误示范：默认使用 delete，会导致未定义行为
std::unique_ptr<int> wrong_ptr(new int[10]); 
// ✅ 正确示范：加上 []
std::unique_ptr<int[]> arr_ptr = std::make_unique<int[]>(10);

  • 神级特性：自定义删除器 (Custom Deleter)：

    智能指针能管任何需要释放的系统资源（文件、网络连接等）。《C++ Primer》强调：删除器的类型，必须作为 unique_ptr 模板参数的一部分。

    CPP
    void myCloseFile(FILE* fp) { if (fp) { fclose(fp); } }
void processFile() {
    // 尖括号类型：<指向的类型, 删除器的类型>
    std::unique_ptr<FILE, decltype(&myCloseFile)> filePtr(fopen("data.txt", "r"), &myCloseFile);
}

    绑定在类型上能让编译器直接生成调用代码，不需要运行期额外花内存存指针，实现零开销。

  • 作为函数的参数和返回值：

    • 只用不抢： 传常量引用 const std::unique_ptr<int>& 或裸指针 p.get()。

    • 接管所有权： 按值传递并配合 std::move()。

    • 作为返回值： 虽然不能拷贝，但可以安全地从函数中返回一个局部的 unique_ptr，编译器会触发特殊优化完美交接。

二、 std::shared_ptr —— 共享型（海王 / 共享单车） ​

如果说 unique_ptr 是绝不分享的“单身狗”和“顶级防盗门钥匙”，那么 shared_ptr 就是可以发给无数人的“共享单车密码”。

  • 核心机制： 允许多个指针指向同一个对象。它是通过引用计数 (Reference Counting) 来实现多个指针共用一个对象的。

  • 底层原理： 每多一个指向，计数 +1；析构一个，计数 -1；当计数为 0 时，释放内存。

1. 引用计数是如何工作的？ ​

在《C++ Primer》中强调，你可以认为每个 shared_ptr 都有一个关联的计数器。

  1. 拷贝/赋值时（计数 +1）： 当你用一个 shared_ptr 初始化另一个，或者把它作为参数按值传递给一个函数，或者作为函数的返回值时，计数器就会递增。

  2. 销毁/重新赋值时（计数 -1）： 当一个 shared_ptr 离开其作用域，或者指向了全新对象时，原对象的计数器就会递减。

  3. 终结（归零）： 一旦计数器变为 0，shared_ptr 就会自动调用对象的析构函数，并释放那块堆内存。

2. 最佳实践：std::make_shared ​

《C++ Primer》强烈建议：最安全的分配和使用动态内存的方法是调用一个名为 make_shared 的标准库函数。

CPP
int main() {
    std::shared_ptr<int> p1 = std::make_shared<int>(100); // count: 1
    {
        std::shared_ptr<int> p2 = p1; // 共享内存，count: 2
    } // p2 销毁，count: 1
    return 0;
} // p1 销毁，count: 0，安全释放！

为什么不用 new？ 使用 new 会分配两次内存（对象一次，控制块一次），而 make_shared 会一次性分配连续内存，效率更高且杜绝中途抛出异常导致的内存泄漏风险。

三、 shared_ptr 的致命陷阱：循环引用 (Circular Reference) ​

智能指针虽然聪明，但也有死穴。《C++ Primer》中明确指出，如果两个对象互相持有对方的 shared_ptr，就会酿成大祸。

DANGER

如果 A 对象存了 B 的 shared_ptr，B 对象又存了 A 的 shared_ptr，它们的引用计数永远不会降为 0，这会导致内存泄漏。

场景重现（双向链表或树节点）：

CPP
struct Node {
    std::shared_ptr<Node> partner; 
    ~Node() { std::cout << "Node destroyed!\n"; }
};

void testLeak() {
    auto nodeA = std::make_shared<Node>(); 
    auto nodeB = std::make_shared<Node>(); 
    nodeA->partner = nodeB; // B 计数变 2
    nodeB->partner = nodeA; // A 计数变 2
} // 函数结束，各自计数变为 1。双方都在等对方放手，内存永远泄漏！

四、 std::weak_ptr —— 破除循环的“备胎” (观察者) ​

为了解决上面的死结，C++ 引入了 weak_ptr。

  • 特点： weak_ptr 是 shared_ptr 的小跟班，它指向对象，但不增加引用计数。

  • 核心使命： 专门用来解决循环引用问题。它只“观察”对象，不“拥有”对象。

  • 使用场景： 观察者模式、缓存表、解决父子节点相互引用的树结构。

规范用法：lock() 方法 ​

因为 weak_ptr 不增加计数，所以它指向的对象随时可能已经被销毁了。C++ 不允许直接访问，必须调用 lock() 方法检查对象是否存活：

  • 存活时，返回有效的 shared_ptr（短暂 +1 保证访问期间不死）。

  • 死亡时，返回空的 shared_ptr。

CPP
struct Node {
    std::weak_ptr<Node> partner; // 改为 weak_ptr，不增加引用计数

    void doSomething() {
        if (std::shared_ptr<Node> shared_partner = partner.lock()) {
            std::cout << "Partner is still alive.\n";
        } else {
            std::cout << "Partner is dead.\n";
        }
    }
};

五、 核心总结 ​

  1. 首选 unique_ptr：只要资源不需要共享，就用它，零开销，绝对安全。

  2. 需要共享时用 shared_ptr：务必配合 make_shared 使用，享受自动计数的便利。

  3. 警惕循环引用：在设计复杂数据结构（图、树、互相引用的对象）时，用 weak_ptr 来打破僵局。

六、 C++ Primer ​

12.1.1 shared_ptr 类：引用计数的脉络 ​

  • make_shared 的绝对统治地位： 书中强调，分配和使用动态内存最安全、最高效的方法就是调用 make_shared。它在动态内存中分配一个对象并初始化它，返回指向此对象的 shared_ptr。它能一次性分配控制块和对象内存，避免了两次分配的开销和潜在的异常泄漏风险。

  • 引用计数的“加减法”条件：

    • 增加（+1）： 当用一个 shared_ptr 初始化另一个 shared_ptr、将它作为参数按值传递给一个函数、或者作为函数的返回值时，计数递增。

    • 减少（-1）： 当给 shared_ptr 赋予一个新值，或者 shared_ptr 被销毁（例如局部变量离开作用域）时，计数递减。

    • 触发释放： 一旦计数器的值变为 0，它就会自动调用底层对象的析构函数，释放动态内存。

12.1.2 直接管理内存：原始的危险操作 ​

  • new 与 bad_alloc 异常： 当自由空间被耗尽时，new 无法为对象分配所要求的内存空间。此时，默认情况下它会抛出一个类型为 std::bad_alloc 的异常。如果你不想让程序因此崩溃，可以使用定位 new（placement new）：int* p = new (nothrow) int;，如果分配失败，它会返回一个空指针。

  • 悬空指针 (Dangling Pointer)： 当你调用 delete p; 释放了内存后，指针 p 变得无效。但是，很多机器上指针 p 仍然保存着那块（已经不属于你的）内存的地址。 这时 p 就是一个悬空指针。如果再去解引用它，会导致未定义行为。

    • 书中的最佳实践： 在 delete 之后，立刻将指针置为 nullptr。

12.1.3 shared_ptr 和 new 结合使用：绝命毒师的“混用” ​

书中严厉警告：永远不要混合使用普通指针和智能指针，也不要使用 get() 初始化另一个智能指针或为智能指针赋值。

  • 隐式转换被禁用： 接受指针参数的智能指针构造函数是 explicit（显式的）。你不能写 shared_ptr<int> p = new int(1024);，只能写成 shared_ptr<int> p(new int(1024));。

  • 经典灾难（Double Free / 悬空指针）：

    当把一个普通指针绑定到一个 shared_ptr 上时，内存的管理责任就交给了这个 shared_ptr。如果你继续使用原来的普通指针，灾难就来了：

    cpp
    int* x = new int(1024); // 危险：x 是一个普通指针
process(shared_ptr<int>(x)); // 临时创建的 shared_ptr 接管了 x。process 函数结束后，临时 shared_ptr 销毁，内存被 delete！
int j = *x; // ❌ 致命错误！x 现在是一个悬空指针，指向的内存已经被释放了。

12.1.4 智能指针和异常：RAII 的安全网 ​

如果在 new 之后、delete 之前发生异常，且该异常未被捕获，那么普通指针管理的内存就会永远泄漏（因为程序跳出了正常执行流，永远执行不到 delete 那一行）。

  • 智能指针的破局之道： 智能指针本质上是栈上的局部对象。C++ 保证，在异常发生并进行栈展开（Stack Unwinding）的过程中，所有的局部对象都会被正常销毁。因此，只要你用智能指针，发生异常时它的析构函数一定会被调用，引用计数递减，从而保证堆内存被安全释放。这就是 RAII（资源获取即初始化）最核心的底气。

12.1.5 unique_ptr：控制权的硬转移 ​

unique_ptr 剥夺了拷贝和赋值的权利，但留下了交接控制权的后门：release 和 reset。

  • release()： 放弃对指针的控制权，返回当前保存的内部裸指针，并将 unique_ptr 置为 nullptr。

    • 高危警告： p2.release(); 这种写法极其危险！它不会释放内存，只会丢掉控制权。如果返回值没有被保存下来去手工 delete 或者交给另一个智能指针，就会造成内存泄漏。

  • reset()： 接受一个可选的指针参数。它会释放 unique_ptr 当前指向的对象（如果有的话），并将 unique_ptr 重新指向新传入的对象。

  • 标准用法（转移所有权）：

    cpp
    unique_ptr<string> p1(new string("Stegosaurus"));
unique_ptr<string> p2(p1.release()); // p2 接管，p1 变为空
unique_ptr<string> p3(new string("Trex"));
p2.reset(p3.release()); // p2 释放原来的 Stegosaurus，接管 Trex，p3 变为空

12.1.6 weak_ptr：用 lock() 探查生死 ​

weak_ptr 指向由 shared_ptr 管理的对象，将一个 weak_ptr 绑定到一个 shared_ptr 不会改变后者的引用计数。

  • 悬空危机： 因为不参与计数，weak_ptr 指向的对象可能随时被其他 shared_ptr 销毁。

  • lock() 函数： 书中规定，不能直接使用 weak_ptr 访问对象，必须调用 lock()。

    • 它会检查 weak_ptr 指向的对象是否还存在。

    • 如果存在（引用计数大于 0），它返回一个指向共享对象的 shared_ptr（此时引用计数安全 +1，确保访问期间对象不会死）。

    • 如果对象已释放，它返回一个空的 shared_ptr。

Released under the MIT License.

Copyright © 2026 Scl