一、shared_ptr 的核心：共享所有权

shared_ptr 是什么？说白了，就是多个指针可以同时拥有同一个对象。

我刚开始学 C++ 那会儿，总觉得这玩意儿有点多余。自己 new 自己 delete 不香吗？直到我在一个大型项目里，被野指针和重复释放折磨得死去活来……嗯，从那以后，shared_ptr 就成了我的标配。

共享所有权的意思很简单：

• 多个 shared_ptr 可以指向同一个堆对象
• 最后一个 shared_ptr 被销毁时，对象才被释放
• 你不用操心谁该 delete，系统自动搞定

二、引用计数原理：到底怎么工作的？

shared_ptr 内部维护了一个引用计数。你想想看，每次拷贝构造或者赋值，计数就加 1。每次析构，计数就减 1。计数归零，对象就 delete。

我习惯把引用计数理解成「房间里的住户数」。住户搬进来，人数加 1；搬出去，人数减 1。最后一个住户搬走，房间就锁了。

#include <memory>
#include <iostream>

class Widget {
public:
    Widget() { std::cout << "Widget created\n"; }
    ~Widget() { std::cout << "Widget destroyed\n"; }
};

int main() {
    std::shared_ptr<Widget> sp1 = std::make_shared<Widget>();
    // 引用计数：1
    
    {
        std::shared_ptr<Widget> sp2 = sp1;
        // 引用计数：2
        std::cout << "use_count: " << sp1.use_count() << "\n";
    }
    // sp2 离开作用域，引用计数：1
    
    // sp1 离开作用域，引用计数：0，对象被销毁
    return 0;
}

输出结果：

Widget created
use_count: 2
Widget destroyed

注意看，对象是在 main 函数结束、sp1 析构时才被销毁的。这就是引用计数的威力。

三、线程安全：shared_ptr 到底安不安全？

这个问题我经常被问到。我的回答是：部分安全。

具体来说：

• 引用计数本身是线程安全的——加减操作是原子的
• 但指向的对象不是线程安全的——你需要自己加锁

我曾经在一个多线程服务器里踩过这个坑。两个线程同时修改 shared_ptr 指向的对象，结果数据全乱了。后来加了个 mutex，问题解决。

// 线程安全的引用计数，但对象本身不安全
std::shared_ptr<std::vector<int>> sp = std::make_shared<std::vector<int>>();

// 线程 A
std::thread t1([&]() {
    sp->push_back(1);  // 不安全！多个线程同时操作 vector
});

// 线程 B
std::thread t2([&]() {
    sp->push_back(2);  // 不安全！
});

t1.join();
t2.join();

正确的做法是加锁：

std::mutex mtx;
std::shared_ptr<std::vector<int>> sp = std::make_shared<std::vector<int>>();

std::thread t1([&]() {
    std::lock_guard<std::mutex> lock(mtx);
    sp->push_back(1);
});

std::thread t2([&]() {
    std::lock_guard<std::mutex> lock(mtx);
    sp->push_back(2);
});

四、循环引用问题：shared_ptr 的阿克琉斯之踵

这是 shared_ptr 最经典的坑。两个对象互相持有对方的 shared_ptr，结果谁也释放不了。

为什么会这样？因为引用计数永远降不到 0。

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

int main() {
    auto a = std::make_shared<Node>();
    auto b = std::make_shared<Node>();
    
    a->next = b;
    b->next = a;
    // 循环引用！a 和 b 都不会被销毁
    
    return 0;
    // 没有输出 "Node destroyed"
}

我在一个图算法项目里遇到过这个问题。节点之间互相引用，内存泄漏得一塌糊涂。排查了整整一个下午才找到原因。

struct Node {
    std::shared_ptr<Node> next;
    std::weak_ptr<Node> prev;  // 用 weak_ptr 打破循环
    ~Node() { std::cout << "Node destroyed\n"; }
};

int main() {
    auto a = std::make_shared<Node>();
    auto b = std::make_shared<Node>();
    
    a->next = b;
    b->prev = a;  // weak_ptr，不增加引用计数
    
    return 0;
    // 两个 Node 都会被销毁
}

五、make_shared 优化：为什么我推荐用它？

我个人习惯，能用 make_shared 就绝不用 new。原因有三：

1. 性能更好——一次内存分配，而不是两次
2. 异常安全——不会因为构造异常导致内存泄漏
3. 代码更简洁——少写一个 new，少一份操心

你想想看，如果用 new：

std::shared_ptr<Widget> sp(new Widget());

这里发生了两次内存分配：一次给 Widget 对象，一次给控制块（包含引用计数）。

而用 make_shared：

auto sp = std::make_shared<Widget>();

只分配一次内存，对象和控制块放在一起。性能提升明显。

不过 make_shared 也有缺点：

• 不能自定义删除器
• 对象和控制块一起分配，如果 weak_ptr 还存在，即使 shared_ptr 全销毁了，对象内存也不会释放

但大多数场景下，make_shared 都是更好的选择。

六、知识体系总览

下面这张图，是我梳理的 shared_ptr 核心知识脉络：

七、总结与避坑指南

shared_ptr 是个好东西，但用不好就是灾难。我总结了几条经验：

• 优先用 make_shared——性能好，代码也干净
• 警惕循环引用——双向关联时，用 weak_ptr 破局
• 别裸 new——除非你需要自定义删除器
• 多线程注意加锁——shared_ptr 不是万能的安全

嗯，shared_ptr 的内容就这些。记住一句话：共享所有权，但别共享混乱。

---

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