C++weak_ptr锁定对象并获取shared_ptr实例-C++-PHP中文网

weak_ptr通过lock()方法安全访问可能失效的对象，返回shared_ptr以临时增加引用计数，确保对象在使用期间不被销毁，若对象已销毁则返回空，从而避免悬空指针。

c++weak_ptr锁定对象并获取shared_ptr实例

C++ weak_ptr

登录后复制

锁定对象并获取

shared_ptr

登录后复制

实例，本质上是为了安全地访问一个可能已经失效的对象。它提供了一种非拥有（non-owning）的引用方式，允许你在不影响对象生命周期的情况下观察它。当你需要使用

weak_ptr

登录后复制

指向的对象时，调用

lock()

登录后复制

方法就能尝试获取一个

shared_ptr

登录后复制

。如果对象仍然存在，你就能得到一个有效的

shared_ptr

登录后复制

并安全地使用它；反之，如果对象已经被销毁，

lock()

登录后复制

会返回一个空的

shared_ptr

登录后复制

。这对于避免悬空指针（dangling pointer）和管理复杂对象图的生命周期至关重要，特别是在处理循环引用或观察者模式时。

要锁定

weak_ptr

登录后复制

并获取其指向的

shared_ptr

登录后复制

实例，你只需要简单地调用

weak_ptr

登录后复制

对象的

lock()

登录后复制

成员函数。这个函数会返回一个

shared_ptr

登录后复制

。如果

weak_ptr

登录后复制

所观察的原始对象仍然存活（即至少有一个

shared_ptr

登录后复制

还在引用它），那么

lock()

登录后复制

会成功返回一个新的

shared_ptr

登录后复制

，这个

shared_ptr

登录后复制

会增加对象的引用计数，确保在你使用它的期间对象不会被销毁。如果原始对象已经被销毁，

lock()

登录后复制

则会返回一个空的

shared_ptr

登录后复制

（即

nullptr

登录后复制

）。因此，在使用返回的

shared_ptr

登录后复制

之前，始终检查它是否为空是最佳实践，也是必须的。在我看来，这是

weak_ptr

登录后复制

最核心的价值所在，它在保证安全性的同时，又提供了灵活的访问机制。没有这个

lock()

登录后复制

，

weak_ptr

登录后复制

的实用性会大打折扣。

#include <iostream>
#include <memory>
#include <vector>

class MyObject {
public:
    int id;
    MyObject(int i) : id(i) {
        std::cout << "MyObject " << id << " created." << std::endl;
    }
    ~MyObject() {
        std::cout << "MyObject " << id << " destroyed." << std::endl;
    }
    void doSomething() {
        std::cout << "MyObject " << id << " is doing something." << std::endl;
    }
};

int main() {
    std::shared_ptr<MyObject> sharedObj = std::make_shared<MyObject>(100);
    std::weak_ptr<MyObject> weakObj = sharedObj;

    // 尝试锁定 weak_ptr 并获取 shared_ptr
    if (auto lockedSharedObj = weakObj.lock()) {
        std::cout << "Object is still alive. ID: " << lockedSharedObj->id << std::endl;
        lockedSharedObj->doSomething();
    } else {
        std::cout << "Object has been destroyed." << std::endl;
    }

    // 让 sharedObj 失效，模拟对象被销毁
    sharedObj.reset(); 
    std::cout << "sharedObj has been reset." << std::endl;

    // 再次尝试锁定 weak_ptr
    if (auto lockedSharedObj = weakObj.lock()) {
        std::cout << "Object is still alive. ID: " << lockedSharedObj->id << std::endl;
        lockedSharedObj->doSomething();
    } else {
        std::cout << "Object has been destroyed." << std::endl;
    }

    // 另一个例子：在作用域结束后
    {
        std::shared_ptr<MyObject> anotherSharedObj = std::make_shared<MyObject>(200);
        std::weak_ptr<MyObject> anotherWeakObj = anotherSharedObj;

        if (auto s = anotherWeakObj.lock()) {
            std::cout << "Another object is alive. ID: " << s->id << std::endl;
        }
    } // anotherSharedObj 在这里超出作用域并被销毁

    if (auto s = weakObj.lock()) { // weakObj 仍然指向之前的被销毁的对象
        std::cout << "This should not happen." << std::endl;
    } else {
        std::cout << "Another object has been destroyed as well (from weakObj's perspective, still empty)." << std::endl;
    }

    if (auto s = anotherWeakObj.lock()) { // anotherWeakObj 指向的对象已被销毁
        std::cout << "This should not happen either." << std::endl;
    } else {
        std::cout << "The object pointed to by anotherWeakObj has indeed been destroyed." << std::endl;
    }

    return 0;
}

登录后复制

为什么

weak_ptr

登录后复制

是解决C++智能指针循环引用的关键？

在我看来，

weak_ptr

登录后复制

诞生的最主要原因之一，就是为了打破

shared_ptr

登录后复制

可能形成的循环引用。当你使用

shared_ptr

登录后复制

构建一个对象图时，如果对象A拥有对象B，同时对象B又拥有对象A，那么它们的引用计数将永远不会降到零，导致这两个对象及其所持有的资源永远无法被释放，这就是经典的内存泄漏。

weak_ptr

登录后复制

提供了一种“旁观者”的角色，它不增加对象的引用计数，仅仅是观察。它允许你建立起这种“弱”关系，即一个对象可以引用另一个对象，但这种引用不会阻止被引用对象的销毁。举个例子，父子关系中，父节点拥有子节点是合理的（

shared_ptr

登录后复制

），但子节点仅仅是“知道”它的父节点，而不应该“拥有”父节点，这时子节点持有父节点的

weak_ptr

登录后复制

就非常合适。它既能访问父节点，又不会阻止父节点在没有其他

shared_ptr

登录后复制

引用的情况下被销毁。说实话，如果没有

weak_ptr

登录后复制

，很多复杂的C++对象关系管理会变得异常棘手，甚至可以说寸步难行。

weak_ptr::lock()

登录后复制

的安全性与潜在陷阱

weak_ptr::lock()

登录后复制

方法的设计理念就是为了提供安全性。它返回一个

shared_ptr

登录后复制

，这意味着如果你成功获取到它，那么在你的

shared_ptr

登录后复制

存活期间，原始对象是保证存在的。这彻底避免了使用原始指针可能导致的悬空指针问题。但这里也有一些值得注意的地方。一个常见的“陷阱”是，有些开发者可能会忘记检查

lock()

登录后复制

的返回值是否为空。如果原始对象已经销毁，

lock()

登录后复制

会返回一个空的

shared_ptr

登录后复制

，如果你不检查就直接解引用它，那就会导致运行时错误。我个人觉得，使用C++17引入的

if (auto locked_ptr = weak_ptr_instance.lock())

登录后复制

这种结构是最好的实践，它简洁又安全。

立即学习“C++免费学习笔记（深入）”；

标书对比王

标书对比王是一款标书查重工具，支持多份投标文件两两相互比对，重复内容高亮标记，可快速定位重复内容原文所在位置，并可导出比对报告。

查看详情

// 推荐的用法
if (auto locked_ptr = myWeakPtr.lock()) {
    // 安全地使用 locked_ptr
    locked_ptr->someMethod();
} else {
    // 对象已失效
    std::cerr << "Warning: Object no longer exists!" << std::endl;
}

// 不推荐的用法（可能导致解引用空指针）
// auto locked_ptr = myWeakPtr.lock();
// locked_ptr->someMethod(); // 如果 locked_ptr 是空的，这里会崩溃

登录后复制

另一个需要注意的细节是，

lock()

登录后复制

操作本身并不是零成本的。它涉及到原子操作来检查引用计数并可能增加它。在性能敏感的代码中，如果频繁地进行

lock()

登录后复制

操作，可能需要评估其开销。但通常情况下，为了保证内存安全，这点开销是完全值得的。毕竟，程序的健壮性往往比极致的微优化更重要。

weak_ptr

登录后复制

在事件系统与缓存管理中的实际应用

weak_ptr

登录后复制

的锁定机制在许多实际场景中都扮演着关键角色。除了前面提到的循环引用，它在构建事件系统（观察者模式）和缓存管理中也显得尤为重要。在事件系统中，一个事件源（Subject）通常会持有一组观察者（Observer）的列表。如果事件源持有观察者的

shared_ptr

登录后复制

，那么即使观察者本身已经不再需要，它也不会被销毁，因为事件源还在引用它。这会导致资源泄漏。通过让事件源持有观察者的

weak_ptr

登录后复制

，当观察者不再被其他地方引用时，它就可以被正常销毁。事件源在通知观察者之前，会尝试

lock()

登录后复制

其

weak_ptr

登录后复制

。如果成功，就说明观察者仍然存活，可以安全地调用其回调方法；如果失败，则说明观察者已经失效，事件源可以将其从列表中移除。这是一种非常优雅且健壮的设计。

// 简化版观察者模式示例
class Observer {
public:
    virtual void onEvent() = 0;
    virtual ~Observer() = default;
};

class Subject {
public:
    void addObserver(std::shared_ptr<Observer> obs) {
        observers_.push_back(obs); // 这里我们为了简化先用shared_ptr，实际通常是weak_ptr
    }
    void notify() {
        // 实际应用中，这里会遍历 weak_ptr 列表，并 lock()
        for (auto& obs : observers_) {
            // 假设这里是 weak_ptr<Observer>
            // if (auto locked_obs = obs.lock()) {
            //     locked_obs->onEvent();
            // }
            obs->onEvent(); // 简化，假设 obs 是 shared_ptr
        }
    }
private:
    std::vector<std::shared_ptr<Observer>> observers_; // 实际应为 std::vector<std::weak_ptr<Observer>>
};

登录后复制

在缓存管理中，