1. 项目概述为什么我们需要 shared_ptr如果你写过 C大概率被内存管理折磨过。手动new和delete就像走钢丝一个不小心就是内存泄漏、悬空指针或者双重释放程序崩溃得莫名其妙。C11 引入的std::shared_ptr就是来终结这种痛苦的。它不是简单的语法糖而是一套基于引用计数的自动化所有权管理机制让你能更专注于业务逻辑而不是整天和内存斗智斗勇。简单说shared_ptr是一种智能指针它允许多个指针“共享”同一个对象的所有权。它会自动追踪有多少个shared_ptr指向同一个对象当最后一个指向该对象的shared_ptr被销毁或重置时它才会自动删除该对象。这听起来像是“垃圾回收”但它是在编译时确定的、确定性的析构没有传统垃圾回收的运行时开销和不确定性是典型的“C风格”的自动化。这篇文章我会结合我十多年踩坑填坑的经验带你从零彻底搞懂shared_ptr。不止是 API 怎么用更重要的是它背后的原理、各种“坑”的成因以及最佳实践。无论你是刚接触 C11 的新手还是想深入理解智能指针的老鸟这篇指南都能让你对shared_ptr有一个全面而立体的认识。2. shared_ptr 的核心机制与内部结构拆解要玩转shared_ptr不能只停留在调用它的成员函数必须理解它肚子里装的是什么。很多人用错了根本原因是对其内部机制一知半解。2.1 引用计数所有权的基石shared_ptr的核心是引用计数。每个被shared_ptr管理的对象或数组都关联着一个控制块。这个控制块里至少包含两个计数器共享所有权计数器记录有多少个shared_ptr正在共享这个对象。当这个计数器减到 0 时对象被销毁调用析构函数并释放内存。弱引用计数器记录有多少个weak_ptr在观察这个对象。这个计数器决定了控制块本身何时被释放。注意use_count()返回的就是共享所有权计数器的值。但请注意use_count()通常只用于调试因为它的值在多线程环境下可能瞬间变化不能用于业务逻辑判断比如if (sp.use_count() 1)来做某些操作是非常不安全的。2.2 控制块隐藏在幕后的管家控制块是一个动态分配的内存块它通常包含以下信息指向被管理对象的指针或对象本身。删除器。分配器。两个引用计数器shared count 和 weak count。这里有一个至关重要的细节直接关系到性能和内存布局控制块是如何创建的通过std::make_shared创建这是最推荐的方式。make_shared会一次性分配一块足够大的内存同时容纳控制块和被管理对象。这种分配方式效率极高一次分配并且由于对象和控制块内存相邻缓存局部性更好。这也是为什么make_shared被强烈推荐的原因之一。通过shared_ptr构造函数从原始指针创建例如shared_ptrT sp(new T)。这种方式会进行两次分配一次为对象new T另一次为控制块new control_block。性能开销更大而且对象和控制块在内存中可能相隔甚远。// 方式一一次分配对象与控制块内存相邻推荐 auto sp1 std::make_sharedMyClass(arg1, arg2); // 方式二两次分配对象与控制块分离 std::shared_ptrMyClass sp2(new MyClass(arg1, arg2));2.3 存储指针 vs 管理指针这是shared_ptr一个高级但容易混淆的特性别名构造。一个shared_ptr实际上持有两个指针存储指针这是get()方法返回的指针也是operator*和operator-操作的对象。管理指针这是传递给删除器、用于最终销毁对象的指针。在绝大多数情况下这两个指针是同一个。但通过别名构造函数shared_ptrT sp(other_sp, ptr)你可以创建一个新的shared_ptr对象sp它共享other_sp对原始对象的所有权即引用同一个控制块但其get()返回的存储指针是另一个指针ptr通常指向原始对象的一个成员或子对象。struct MyStruct { int value 42; }; int main() { auto owner std::make_sharedMyStruct(); // 管理整个 MyStruct 对象 std::shared_ptrint alias(owner, owner-value); // 别名指针 std::cout owner.get() std::endl; // 输出 MyStruct 对象的地址 std::cout alias.get() std::endl; // 输出 MyStruct::value 成员的地址 std::cout *alias std::endl; // 输出 42 // 当 owner 和 alias 都销毁后MyStruct 对象才会被释放 }这个特性非常有用例如在实现std::enable_shared_from_this时或者当你需要让一个智能指针指向某个对象的成员但同时又要保持该对象本身的生命周期时。3. 从零开始shared_ptr 的基本用法与构造理解了内部机制我们再看如何使用它。shared_ptr的构造方式多样选择正确的构造方式能避免很多陷阱。3.1 推荐的构造方式std::make_shared这是你的首选没有之一。#include memory #include iostream class Widget { public: Widget(int id, const std::string name) : m_id(id), m_name(name) { std::cout Widget( id , name ) constructed.\n; } ~Widget() { std::cout Widget destroyed.\n; } void print() const { std::cout ID: m_id , Name: m_name std::endl; } private: int m_id; std::string m_name; }; int main() { // 使用 make_shared完美转发参数给构造函数 auto widget std::make_sharedWidget(1, AwesomeWidget); widget-print(); // 像普通指针一样使用 // 离开作用域widget 被销毁引用计数归零Widget 对象自动析构 }为什么强烈推荐make_shared异常安全考虑函数foo(std::shared_ptrT(new T), bar())。C 并未规定函数参数的求值顺序。如果执行顺序是new T-bar()-shared_ptr 构造函数而bar()抛出了异常那么new T分配的内存就泄漏了。make_shared将对象构造和控制块分配合并为一个原子操作杜绝了此类泄漏。性能更优如前所述一次内存分配更好的缓存局部性。代码更简洁无需显式写出类型T使用auto即可。3.2 其他构造方式及注意事项虽然make_shared是首选但有些场景下你不得不使用其他方式。从原始指针构造Widget* raw_ptr new Widget(2, RawWidget); std::shared_ptrWidget sp1(raw_ptr); // 从此以后绝对不能再使用 raw_ptr 或对其进行 delete // 所有权已转移给 sp1致命陷阱绝对不要用同一个原始指针初始化多个独立的shared_ptr。Widget* p new Widget; std::shared_ptrWidget sp1(p); std::shared_ptrWidget sp2(p); // 灾难两个独立的控制块都会试图删除 p这会导致对象被双重释放引发未定义行为通常是程序崩溃。一个原始指针只能交给一个shared_ptr“托管”一次。自定义删除器当管理对象不是通过new分配或者需要特殊清理逻辑时需要自定义删除器。// 管理一个 FILE*删除器调用 fclose std::shared_ptrFILE filePtr(fopen(data.txt, r), [](FILE* fp) { if (fp) { fclose(fp); std::cout File closed.\n; } }); // 管理数组C17前make_shared 不支持数组需自定义删除器 std::shared_ptrint[] arrPtr(new int[10], [](int* p) { delete[] p; }); // C17 后shared_ptr 直接支持数组make_shared 也支持 auto arrPtr2 std::shared_ptrint[](new int[10]); // 正确 // auto arrPtr3 std::make_sharedint[10](); // C20 起支持拷贝构造与赋值共享所有权auto sp1 std::make_sharedWidget(3, Original); std::shared_ptrWidget sp2(sp1); // 拷贝构造引用计数1 std::shared_ptrWidget sp3; sp3 sp1; // 拷贝赋值sp3 原来管理的对象如果有引用计数-1现在共享 sp1 的对象计数再1 std::cout sp1.use_count() std::endl; // 输出 3移动语义转移所有权auto sp1 std::make_sharedWidget(4, Movable); std::shared_ptrWidget sp2(std::move(sp1)); // 移动构造sp1 变为空引用计数不变还是1 // 此时 sp1.get() nullptr, sp1.use_count() 0 std::shared_ptrWidget sp3; sp3 std::move(sp2); // 移动赋值sp2 变为空移动操作效率很高因为它只转移了内部指针和控制块指针不涉及引用计数的原子操作。4. 关键成员函数与操作详解掌握了构造我们来看看shared_ptr提供哪些核心操作。4.1 观察器获取信息get(): 返回存储的原始指针。慎用除非你需要将指针传递给不识别智能指针的遗留 API否则不要轻易获取原始指针。更不要对它进行delete操作。operator*和operator-: 解引用像使用普通指针一样访问对象。use_count(): 返回共享所有权计数。仅用于调试不要用于程序逻辑。operator bool(): 判断是否为空即是否管理着一个对象。if (sp) { /* sp 非空 */ }。4.2 修改器改变管理对象reset(): 重置shared_ptr。sp.reset(): 放弃当前管理的对象的所有权。如果它是最后一个所有者则对象被销毁。sp变为空。sp.reset(new T): 放弃当前对象改为管理新的new T对象。sp.reset(new T, custom_deleter): 放弃当前对象改为管理新对象并指定删除器。swap(): 交换两个shared_ptr的内容。auto sp1 std::make_sharedint(100); auto sp2 std::make_sharedint(200); std::cout *sp1 , *sp2 std::endl; // 100, 200 sp1.swap(sp2); std::cout *sp1 , *sp2 std::endl; // 200, 100 // 等价于 std::swap(sp1, sp2)4.3 类型转换static_pointer_cast, dynamic_pointer_cast, const_pointer_cast这些函数类似于 C 的static_cast,dynamic_cast,const_cast但用于shared_ptr。它们会创建一个新的shared_ptr转换其存储的指针类型同时共享原指针的所有权。class Base { public: virtual ~Base() default; }; class Derived : public Base {}; std::shared_ptrBase basePtr std::make_sharedDerived(); // 向下转换安全使用 dynamic_pointer_cast std::shared_ptrDerived derivedPtr std::dynamic_pointer_castDerived(basePtr); if (derivedPtr) { // 转换成功 } // 向上转换安全但通常直接赋值即可派生类指针可赋给基类智能指针 std::shared_ptrBase basePtr2 derivedPtr; // 移除 const谨慎使用 const std::shared_ptrconst int constPtr std::make_sharedconst int(5); std::shared_ptrint mutablePtr std::const_pointer_castint(constPtr);5. 进阶主题与经典陷阱剖析会用基本 API 只是入门真正考验功力的是如何处理复杂场景和规避陷阱。5.1 循环引用shared_ptr 的阿喀琉斯之踵这是shared_ptr最经典的问题。当两个或多个对象通过shared_ptr互相引用时它们的引用计数永远无法降到零导致内存泄漏。struct Node { std::shared_ptrNode next; std::shared_ptrNode prev; // 互相持有 shared_ptr ~Node() { std::cout Node destroyed\n; } }; int main() { auto node1 std::make_sharedNode(); auto node2 std::make_sharedNode(); node1-next node2; node2-prev node1; // 循环引用形成 // 离开作用域node1 和 node2 的引用计数仍为1互相引用对象永远不会被销毁。 }解决方案使用std::weak_ptr。weak_ptr是一种“弱引用”它指向一个由shared_ptr管理的对象但不增加其引用计数。它用于打破循环引用中的“强所有权”链。struct NodeSafe { std::shared_ptrNodeSafe next; std::weak_ptrNodeSafe prev; // 将一方改为 weak_ptr ~NodeSafe() { std::cout NodeSafe destroyed\n; } }; int main() { auto node1 std::make_sharedNodeSafe(); auto node2 std::make_sharedNodeSafe(); node1-next node2; node2-prev node1; // prev 是 weak_ptr不增加 node1 的引用计数 // 离开作用域 // node2 引用计数变为0先被销毁。 // node2 销毁导致其成员 next 被销毁node1 的引用计数减1。 // node1 引用计数变为0随后被销毁。 }使用weak_ptr时需要通过lock()方法尝试获取一个临时的shared_ptr来访问对象因为对象可能已被销毁。if (auto sp weakPtr.lock()) { // 对象还存在可以安全使用 sp sp-doSomething(); } else { // 对象已被释放 }5.2 std::enable_shared_from_this从 this 安全获取 shared_ptr考虑这样一个场景在一个类的成员函数内部你需要将对象自身this传递给一个需要shared_ptrT参数的函数。直接传递this指针然后构造一个新的shared_ptr是灾难性的会创建新的控制块导致双重释放。class BadWidget { public: void process() { // 错误这会用同一个 this 创建第二个控制块。 someFunctionThatTakesSharedPtr(std::shared_ptrBadWidget(this)); } };正确的做法是让类继承自std::enable_shared_from_thisT然后使用shared_from_this()成员函数。class GoodWidget : public std::enable_shared_from_thisGoodWidget { public: void process() { // 正确返回一个与现有控制块共享所有权的 shared_ptr。 auto self shared_from_this(); someFunctionThatTakesSharedPtr(self); } // 注意对象必须已经被 shared_ptr 管理才能调用 shared_from_this。 // 即不能对栈上对象或独立 new 出来的对象调用它。 }; int main() { auto widget std::make_sharedGoodWidget(); // 必须通过 shared_ptr 管理 widget-process(); // 安全 }关键限制在对象的构造函数中不能调用shared_from_this()因为此时对象的shared_ptr尚未完全构造好。5.3 多线程安全它安全吗这是一个常见的误解。shared_ptr的引用计数操作是原子且线程安全的。这意味着多个线程同时拷贝、赋值、销毁指向同一个对象的不同shared_ptr实例是安全的。但是shared_ptr管理的对象本身并不是线程安全的。多个线程通过不同的shared_ptr实例去读写同一个对象需要额外的同步机制如互斥锁。更重要的是对同一个shared_ptr实例进行写操作如reset,operator不是线程安全的需要加锁。读操作如get,use_count与写操作并发也不是线程安全的。// 线程安全操作指向同一对象的不同 shared_ptr 实例 std::shared_ptrint global_sp std::make_sharedint(0); void thread_func(std::shared_ptrint local_sp) { // 传值每个线程有自己的拷贝 // 对 local_sp 的操作是线程安全的因为每个线程操作自己的副本 // 但通过 local_sp 修改 *local_sp 的值需要同步 } // 线程不安全多个线程操作同一个 shared_ptr 实例 std::shared_ptrint shared_sp; void unsafe_thread_func() { shared_sp std::make_sharedint(42); // 需要锁保护 }对于需要原子更新shared_ptr的场景C20 提供了std::atomicstd::shared_ptrT但在 C20 之前可以使用std::atomic_load,std::atomic_store等自由函数现已不推荐。5.4 性能考量与开销shared_ptr不是零成本的抽象它的开销主要来自内存开销每个被管理的对象都需要一个控制块通常包含引用计数、删除器、分配器等大小可能是原始指针的两倍或更多。运行时开销拷贝/赋值需要原子地递增递减引用计数。虽然原子操作在现代 CPU 上很快但在高性能循环中频繁拷贝shared_ptr仍需注意。析构开销引用计数归零时需要检查弱引用计数来决定是否释放控制块然后调用删除器。优化建议优先按值传递shared_ptr除非你有明确的理由如需要修改指针本身否则在函数参数中按值传递shared_ptr。这明确表示了所有权的共享并且是线程安全的因为每个函数栈帧有自己的副本。使用const引用避免不必要的拷贝如果函数只需要“观察”对象而不需要共享所有权或延长其生命周期应该传递const std::shared_ptrT或T*通过sp.get()或T通过*sp。考虑使用std::move在可以转移所有权的场景如将shared_ptr存入容器使用移动语义避免引用计数的原子操作。6. 实战shared_ptr 在典型场景中的应用理论说再多不如看几个实际例子。6.1 场景一工厂模式返回对象工厂函数创建对象但调用者需要管理其生命周期。返回shared_ptr是理想选择。class Product { public: virtual void use() 0; virtual ~Product() default; }; class ConcreteProductA : public Product { void use() override { std::cout Using A\n; } }; class ConcreteProductB : public Product { void use() override { std::cout Using B\n; } }; enum class ProductType { A, B }; std::shared_ptrProduct createProduct(ProductType type) { switch (type) { case ProductType::A: return std::make_sharedConcreteProductA(); case ProductType::B: return std::make_sharedConcreteProductB(); default: return nullptr; } } int main() { auto prod createProduct(ProductType::A); if (prod) { prod-use(); } // prod 销毁时产品对象自动释放 }6.2 场景二实现对象缓存Object Pool缓存需要管理一批可重用的对象。当客户端请求对象时从缓存中取出一个shared_ptr当客户端用完shared_ptr析构对象引用计数减一但可能因为缓存中仍有引用而不会被销毁从而回到池中。class Connection { /* ... */ }; class ConnectionPool { std::vectorstd::shared_ptrConnection pool; std::mutex pool_mutex; public: std::shared_ptrConnection getConnection() { std::lock_guardstd::mutex lock(pool_mutex); if (!pool.empty()) { auto conn pool.back(); pool.pop_back(); // 这里可以重置连接状态 return conn; } // 池为空创建新连接 return std::make_sharedConnection(); } void returnConnection(std::shared_ptrConnection conn) { std::lock_guardstd::mutex lock(pool_mutex); // 这里可以检查连接是否有效 pool.push_back(std::move(conn)); } // 注意实际实现会更复杂需要考虑连接有效性、最大连接数等。 }; // 客户端使用后conn 的析构会自动将引用还给池如果池持有引用或关闭连接如果池已满/关闭。6.3 场景三管理动态数组C17及以后C17 扩展了shared_ptr对数组的支持使得管理动态数组更加方便。// C17 之前需要自定义删除器 std::shared_ptrint oldArr(new int[10], std::default_deleteint[]()); // C17 及以后直接使用模板特化 std::shared_ptrint[] arr(new int[10]); // 正确会调用 delete[] arr[0] 1; // 支持 operator[] // C20 及以后甚至可以结合 make_shared (部分编译器支持) // auto arr2 std::make_sharedint[](10);7. 常见问题排查与调试技巧即使理解了原理实际使用中还是会遇到各种问题。这里记录一些我踩过的坑和调试方法。7.1 问题内存没有释放疑似泄漏可能原因 1循环引用。这是最常见的原因。检查对象间的引用关系特别是父子节点、观察者模式等。使用weak_ptr替换不必要的shared_ptr。排查工具Valgrind (Massif)可以分析堆内存使用情况查看哪些对象没有被释放。自定义删除器打印日志在删除器中加入日志输出确认对象是否被析构。auto sp std::shared_ptrMyClass(new MyClass, [](MyClass* p) { std::cout Deleting MyClass at p std::endl; delete p; });可能原因 2shared_ptr被意外地长期持有。例如将shared_ptr存储在某个全局容器或静态变量中忘记了清理。排查方法审查代码追踪shared_ptr的生命周期。确保在适当的时候调用reset()或离开作用域。7.2 问题程序崩溃访问无效内存可能原因 1悬空指针。通过get()获取了原始指针并在shared_ptr释放对象后继续使用它。int* risky_ptr nullptr; { auto sp std::make_sharedint(42); risky_ptr sp.get(); } // sp 离开作用域对象被销毁 *risky_ptr 10; // 崩溃访问已释放内存解决方案尽量避免存储和使用get()返回的指针。如果必须使用确保其生命周期被一个shared_ptr覆盖。可能原因 2误用enable_shared_from_this。在对象尚未被shared_ptr管理时例如栈对象或直接new出来的对象调用了shared_from_this()会抛出std::bad_weak_ptr异常。class Widget : public std::enable_shared_from_thisWidget {}; Widget stackWidget; // 错误栈对象 auto sp stackWidget.shared_from_this(); // 抛出异常 Widget* raw new Widget; // 错误裸指针 auto sp2 raw-shared_from_this(); // 抛出异常解决方案确保对象总是通过std::make_sharedWidget()或std::shared_ptrWidget(new Widget)来创建。7.3 问题性能瓶颈可能原因在关键循环或高频调用路径中大量拷贝shared_ptr导致原子操作成为瓶颈。排查工具使用性能分析工具如perf,VTune,Callgrind定位热点代码。优化策略传递 const 引用对于只读访问。使用std::move转移所有权避免原子递增。重新设计考虑是否真的需要共享所有权能否使用unique_ptr或原始指针/引用unique_ptr的开销小得多。7.4 调试技巧自定义删除器追踪给重要的资源如文件句柄、网络连接、数据库连接的shared_ptr加上一个打印日志的删除器是追踪生命周期和发现泄漏的利器。templatetypename T struct DebugDeleter { std::string resourceName; void operator()(T* ptr) const { std::cout [Debug] Deleting resource: resourceName at address: ptr std::endl; delete ptr; // 或调用 ptr-close() 等 } }; auto dbConn std::shared_ptrDatabaseConnection( new DatabaseConnection, DebugDeleterDatabaseConnection{MainDB} );8. 总结与最佳实践清单经过上面长篇累牍的讨论我们可以提炼出一套使用shared_ptr的最佳实践这能帮你避开 90% 的坑首选std::make_shared除非有特殊需求如自定义删除器、需要分离对象和控制块分配否则永远用它来创建shared_ptr。它更安全、更高效。避免使用裸指针初始化多个shared_ptr一个原始指针只交给一个shared_ptr管理一次。如果需要共享拷贝已有的shared_ptr。警惕循环引用在可能存在环形引用的数据结构如双向链表、树形结构、观察者模式中使用std::weak_ptr来打破循环。正确使用enable_shared_from_this仅在对象已被shared_ptr管理的情况下调用shared_from_this()。不要在构造函数中调用。理解线程安全模型shared_ptr的引用计数操作是原子的但对象访问和同一个shared_ptr实例的读写需要同步。按值传递以共享所有权函数如果需要共享所有权接受shared_ptr值参。如果只是观察接受const shared_ptr或原始指针/引用。慎用get()不要保存get()返回的指针不要对它进行delete操作。它的生命周期受限于shared_ptr本身。优先考虑unique_ptr在所有权单一、明确的场景下std::unique_ptr是更轻量、更高效的选择。只在真正需要共享所有权时才使用shared_ptr。管理数组使用 C17 语法对于动态数组使用shared_ptrT[]并配合new T[]或等待 C20 的make_sharedT[]完全普及。性能敏感处注意开销意识到shared_ptr的内存和原子操作开销。在性能关键路径上评估所有权模型是否必要。shared_ptr是 C 现代内存管理的基石之一它极大地减轻了开发者的负担。但正如所有强大的工具只有深入理解其原理和边界才能用得顺手、用得放心。希望这篇指南能成为你手边一份可靠的参考。在实际编码中多思考所有权语义善用make_shared和weak_ptr你的 C 代码会变得更加健壮和清晰。