You need to enable JavaScript to run this app. 应用场景下std::weak_ptr相较std::shared_ptr的优先使用时机与代码示例
优惠活动
大模型
产品
解决方案
定价
更多

应用场景下std::weak_ptr相较std::shared_ptr的优先使用时机与代码示例

优先选用std::weak_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

相关产品推荐
方舟 Agent Plan

超全模态模型 × Harness 升级,最新支持 Deepseek-V4.1-Flash、GLM-5.3 系列、Doubao-Seedream-5.0-pro、Kimi-K3 (部分), 限时 9.9 元起

最近更新时间:2026.11.05 17:45:03