5. 智能指针总览：auto_ptr 的弃用、unique_ptr、shared_ptr、weak_ptr 的引入与定位

说到智能指针，我得先坦白一件事。我刚入行那会儿，C++ 里还没有智能指针这玩意儿。那时候写代码，new 和 delete 就像吃饭喝水一样平常。嗯，后果你也猜到了——内存泄漏、悬空指针、double free……这些坑我几乎踩了个遍。

后来 C++11 标准出来了，智能指针正式成为语言的一部分。说实话，我第一次看到 unique_ptr 和 shared_ptr 的时候，心里想的是：「早该这样了！」

这一章，我们就来聊聊智能指针的「家族史」。为什么 auto_ptr 被抛弃了？unique_ptr、shared_ptr、weak_ptr 各自扮演什么角色？

5.1 auto_ptr：一个「早产儿」的悲剧

auto_ptr 是 C++98 时代引入的第一个智能指针。它的设计初衷是好的——自动管理动态对象的生命周期。但问题在于，它的实现方式有严重缺陷。

核心问题是什么？拷贝语义。

auto_ptr 的拷贝构造函数和赋值运算符会转移所有权，而不是复制对象。这意味着，当你把一个 auto_ptr 赋值给另一个时，原来的指针就变成了 nullptr。

// auto_ptr 的典型问题
std::auto_ptr<int> p1(new int(42));
std::auto_ptr<int> p2 = p1;  // p1 现在变成了 nullptr

// 如果你不小心继续使用 p1……
*p1 = 100;  // 崩溃！解引用空指针

我在项目中遇到过这样的场景：一个函数返回 auto_ptr，调用方拿到后顺手又拷贝了一份。结果原指针失效，程序莫名其妙地崩溃。调试了整整一个下午才找到原因。

我曾经踩过的坑：把 auto_ptr 放进标准容器里。比如 std::vector<std::auto_ptr<int>>。容器在扩容时会拷贝元素，结果原来的 auto_ptr 全变成了空指针。程序跑着跑着就挂了，而且很难复现。

正因为这些设计缺陷，C++11 标准正式弃用了 auto_ptr。C++17 中它已经被彻底移除。如果你还在用 auto_ptr，我建议你立刻换成 unique_ptr。

5.2 unique_ptr：独占所有权的「独行侠」

unique_ptr 是 auto_ptr 的替代品。它解决了 auto_ptr 最让人头疼的问题——隐式的所有权转移。

unique_ptr 的核心特点是：独占所有权，不可拷贝，只能移动。

// unique_ptr 的正确用法
std::unique_ptr<int> p1 = std::make_unique<int>(42);
// std::unique_ptr<int> p2 = p1;  // 编译错误！不能拷贝
std::unique_ptr<int> p2 = std::move(p1);  // 必须显式移动

// 移动后，p1 变成空指针
if (!p1) {
    std::cout << "p1 已经空了" << std::endl;
}

你想想看，这种设计有什么好处？所有权转移变得显式了。你一眼就能看出代码在做什么，不会像 auto_ptr 那样偷偷摸摸地把指针置空。

我个人习惯用 std::make_unique 来创建 unique_ptr。原因很简单：异常安全。如果你直接用 new，万一构造函数抛异常，内存就泄漏了。make_unique 能避免这个问题。

小技巧：在函数参数中传递 unique_ptr 时，建议用 std::move 显式转移所有权。这样代码的意图一目了然。

5.3 shared_ptr：共享所有权的「社交达人」

有时候，一个对象需要被多个地方共享。比如一个缓存系统，多个线程都要访问同一个数据。这时候 unique_ptr 就不够用了。

shared_ptr 就是为这种场景设计的。它使用引用计数来管理对象的生命周期。当最后一个 shared_ptr 被销毁时，对象才会被释放。

// shared_ptr 的基本用法
std::shared_ptr<int> p1 = std::make_shared<int>(42);
std::shared_ptr<int> p2 = p1;  // 引用计数变为 2

std::cout << "引用计数: " << p1.use_count() << std::endl;  // 输出 2

p1.reset();  // p1 置空，引用计数变为 1
p2.reset();  // p2 置空，引用计数变为 0，对象被释放

这里有个关键点：引用计数的线程安全性。shared_ptr 的引用计数操作是原子性的，所以多线程环境下是安全的。但注意，指向的对象本身不是线程安全的。如果你要修改对象，还是需要加锁。

我曾经踩过的坑：用 shared_ptr 管理一个数组。默认情况下，shared_ptr 的删除器调用的是 delete，而不是 delete[]。结果就是只释放了数组的第一个元素，剩下的全泄漏了。正确的做法是提供自定义删除器：std::shared_ptr<int> p(new int[10], std::default_delete<int[]>())。

5.4 weak_ptr：打破循环引用的「观察者」

shared_ptr 虽然好用，但有一个致命问题：循环引用。

想象一下，两个对象互相持有对方的 shared_ptr。它们的引用计数永远不会降到 0，内存就泄漏了。

// 循环引用的典型场景
struct Node {
    std::shared_ptr<Node> next;
    ~Node() { std::cout << "Node 被销毁" << std::endl; }
};

auto a = std::make_shared<Node>();
auto b = std::make_shared<Node>();
a->next = b;
b->next = a;  // 循环引用！两个 Node 都不会被销毁

weak_ptr 就是来解决这个问题的。它像一个「观察者」，可以访问 shared_ptr 管理的对象，但不会增加引用计数。

// 用 weak_ptr 打破循环引用
struct Node {
    std::weak_ptr<Node> next;  // 改用 weak_ptr
    ~Node() { std::cout << "Node 被销毁" << std::endl; }
};

auto a = std::make_shared<Node>();
auto b = std::make_shared<Node>();
a->next = b;
b->next = a;  // 现在没问题了，引用计数不会增加

使用 weak_ptr 时，你需要先调用 lock() 方法获取一个临时的 shared_ptr。如果对象已经被释放，lock() 会返回空指针。

我建议：在需要「观察但不拥有」的场景下，优先考虑 weak_ptr。比如缓存系统、观察者模式、树形结构中的父节点引用等。

5.5 知识体系总览

下面这张图总结了四种智能指针的核心关系和使用场景：

智能指针家族总览 auto_ptr C++98 引入 C++11 弃用 ✗ 拷贝语义缺陷 unique_ptr 独占所有权 只能移动 ✓ 替代 auto_ptr shared_ptr 共享所有权 引用计数 ✓ 多线程安全 weak_ptr 观察者模式 不增加引用计数 ✓ 打破循环引用 被替代 可转换 可创建 核心原则：优先使用 unique_ptr，需要共享时用 shared_ptr，用 weak_ptr 打破循环引用 独占资源 共享数据 观察/缓存

5.6 如何选择？我的经验法则

说了这么多，到底该用哪个？我总结了一个简单的决策流程：

  1. 默认用 unique_ptr。它的开销最小，语义最清晰。大部分场景下，独占所有权就够了。
  2. 需要共享时用 shared_ptr。但要注意循环引用的问题。
  3. 用 weak_ptr 打破循环引用。或者用于缓存、观察者模式等场景。
  4. 永远不要用 auto_ptr。如果你在旧代码里看到它，立刻换成 unique_ptr。

核心原则：智能指针不是银弹。它们管理的是所有权，而不是生命周期。你仍然需要理解对象的生命周期，才能正确地使用它们。

好了，这一章就到这里。下一章我们会深入 unique_ptr 的实现细节和高级用法。到时候我会分享一些我在实际项目中用到的技巧。

公众号:蓝海资料掘金营，微信deep3321

← 上一章 📖 返回目录 下一章 →