应用场景下std::weak_ptr相较std::shared_ptr的优先使用时机与代码示例
你已经清楚两个智能指针的基础机制差异,下面直接列weak_ptr相较shared_ptr有明确选型优势的场景,每个场景配可复现的示例和原因说明:
1. 打破循环引用导致的内存泄漏
当两个对象需要互相持有对方的引用时,如果双方都用shared_ptr保存对方的指针,会形成循环引用:每个对象的强引用计数被对方持有1份,哪怕外部所有指向这两个对象的shared_ptr都超出作用域,两个对象的引用计数永远停在1,永远不会触发析构,造成永久内存泄漏。
这时候把其中一方的引用改成weak_ptr,因为弱引用不增加强引用计数,就可以正常让引用计数归零,触发对象析构。
示例代码:
#include <memory> #include <iostream> struct B; struct A { std::shared_ptr<B> b_ptr; ~A() { std::cout << "A 被销毁\n"; } }; struct B { // 如果替换为std::shared_ptr<A>,就会触发循环引用泄漏 std::weak_ptr<A> a_ptr; ~B() { std::cout << "B 被销毁\n"; } }; int main() { auto a = std::make_shared<A>(); auto b = std::make_shared<B>(); a->b_ptr = b; b->a_ptr = a; // 程序退出时,A和B对象都能正常完成析构,无内存泄漏 }
2. 实现不持有对象生命周期的资源缓存
做资源缓存时的核心矛盾是:缓存只需要提供资源的快速访问能力,不应该决定资源的生命周期——如果外部代码已经不再使用某份资源,这份资源就应该被及时回收,而不是被缓存一直攥着占用内存。
如果用shared_ptr存缓存条目,会让缓存成为资源的强引用持有者,哪怕外部没有任何代码在用这份资源,缓存条目没被手动清理的话,资源永远不会被释放,长期运行会造成内存膨胀。
换成weak_ptr存缓存条目就完美适配这个需求:外部最后一个强引用释放时,资源自动析构,对应缓存里的弱引用会自动标记为失效,下次访问时自动清理失效条目,不需要额外的缓存清理逻辑。
示例代码:
#include <memory> #include <unordered_map> #include <string> // 假设的高占用内存重资源 class HeavyTexture { public: void Load() { /* 模拟加载几MB的纹理资源 */ } }; // 全局纹理缓存 std::unordered_map<std::string, std::weak_ptr<HeavyTexture>> g_texture_cache; // 对外提供纹理获取接口 std::shared_ptr<HeavyTexture> GetTexture(const std::string& path) { auto iter = g_texture_cache.find(path); if (iter != g_texture_cache.end()) { // 尝试把弱引用提升为强引用 auto cached = iter->second.lock(); if (cached) { return cached; // 缓存有效直接返回 } // 弱引用已经失效,删除过期缓存条目 g_texture_cache.erase(iter); } // 重新加载新的纹理资源 auto new_tex = std::make_shared<HeavyTexture>(); new_tex->Load(); g_texture_cache[path] = new_tex; return new_tex; }
3. 观察者模式的订阅关系存储
发布-订阅模型中,发布者需要维护所有订阅者的列表。如果用shared_ptr存订阅者指针,会带来两个问题:
- 发布者会意外保活订阅者——哪怕订阅者的业务生命周期已经结束,只要发布者还存在,订阅者就永远析构不了
- 如果发布者的生命周期比订阅者长,订阅者析构后发布者存的指针就变成野指针,回调时会触发崩溃
这时候用weak_ptr存订阅者列表就没有这个问题:弱引用不参与强引用计数,不会保活订阅者;每次发事件前先尝试把弱引用提升为强引用,能拿到有效对象才执行回调,拿不到就自动把失效的订阅条目从列表里删掉,甚至不需要订阅者在析构时手动调用反注册接口。
示例代码:
#include <memory> #include <vector> #include <iostream> class IEventListener { public: virtual void OnTrigger() = 0; virtual ~IEventListener() = default; }; class EventPublisher { std::vector<std::weak_ptr<IEventListener>> listeners_; public: void Subscribe(std::shared_ptr<IEventListener> listener) { listeners_.push_back(listener); } void Notify() { for (auto it = listeners_.begin(); it != listeners_.end();) { auto listener = it->lock(); if (listener) { listener->OnTrigger(); ++it; } else { // 订阅者已销毁,自动移除条目 it = listeners_.erase(it); } } } }; class ButtonListener : public IEventListener { public: void OnTrigger() override { std::cout << "按钮点击事件被触发\n"; } ~ButtonListener() { std::cout << "按钮监听器被销毁\n"; } }; int main() { EventPublisher btn; { auto listener = std::make_shared<ButtonListener>(); btn.Subscribe(listener); btn.Notify(); // 正常收到事件 } // 出作用域后listener已经析构 btn.Notify(); // 自动清理失效条目,无野指针访问、无内存泄漏 }
4. 异步回调中的安全自引用传递
给类的成员函数做异步回调时,必须传this指针才能访问成员变量。如果直接传裸指针,对象析构后回调触发时就会访问野指针;如果传shared_ptr形式的this(通过shared_from_this()获取),回调持有强引用会意外延长对象的生命周期——哪怕外部所有强引用都释放了,只要回调还在队列里排队,对象就会一直存活到回调执行完。
这时候用weak_from_this()获取对象的弱引用传到回调里,既保证了访问安全:回调执行时先lock()判断对象是否存活,存活才执行逻辑;又不会因为回调的存在意外保活对象,对象可以在外部强引用全部释放时正常析构,排队的失效回调会自动跳过执行。
示例代码:
#include <memory> #include <thread> #include <chrono> class NetworkClient : public std::enable_shared_from_this<NetworkClient> { public: void SendRequestAsync() { // 传递弱引用而非强引用 auto weak_self = weak_from_this(); std::thread([weak_self]() { // 模拟网络请求耗时1秒 std::this_thread::sleep_for(std::chrono::seconds(1)); auto self = weak_self.lock(); if (!self) { // 客户端已经销毁,直接丢弃响应 return; } self->OnResponseReceived(); }).detach(); } void OnResponseReceived() { // 处理网络响应逻辑 } };
内容的提问来源于stack exchange,提问作者Jackattack

