C++weak_ptr避免悬空指针访问策略-C++-PHP中文网

C++weak_ptr避免悬空指针访问策略

P粉602998670

发布： 2025-09-03 11:12:01

原创

513人浏览过

weak_ptr用于解决shared_ptr的循环引用和悬空指针问题，通过不增加引用计数实现对对象的弱引用，需配合lock()安全访问目标对象。

c++weak_ptr避免悬空指针访问策略

弱指针（

weak_ptr

登录后复制

）在C++中被设计用来解决共享所有权中可能出现的悬空指针问题。简单来说，它允许你观察一个对象，而不会增加该对象的引用计数，因此不会阻止该对象被销毁。当对象被销毁后，

weak_ptr

登录后复制

会自动失效，避免了悬空指针的访问。

解决方案

使用

weak_ptr

登录后复制

的核心策略在于：在你需要观察一个对象，但不希望影响其生命周期时，使用

weak_ptr

登录后复制

。当你实际需要访问对象时，先检查

weak_ptr

登录后复制

是否仍然有效。

创建

weak_ptr

登录后复制

：从

shared_ptr

登录后复制

创建。

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

#include <iostream>
#include <memory>

int main() {
    std::shared_ptr<int> sharedPtr = std::make_shared<int>(42);
    std::weak_ptr<int> weakPtr = sharedPtr; // 从 shared_ptr 创建 weak_ptr

    // ...
}

登录后复制

检查有效性： 使用

expired()

登录后复制

或

lock()

登录后复制

方法。

expired()

登录后复制

true

登录后复制

如果对象已被销毁，

lock()

登录后复制

返回一个新的

shared_ptr

登录后复制

如果对象仍然存在，否则返回空的

shared_ptr

登录后复制

。

if (!weakPtr.expired()) {
    std::shared_ptr<int> sharedPtrFromWeak = weakPtr.lock(); // 尝试获取 shared_ptr
    if (sharedPtrFromWeak) {
        std::cout << "Value: " << *sharedPtrFromWeak << std::endl; // 安全访问
    } else {
        std::cout << "Object no longer exists." << std::endl;
    }
} else {
    std::cout << "Object already expired." << std::endl;
}

登录后复制

使用

lock()

登录后复制

进行安全访问： 这是推荐的方式，因为它在一个操作中完成了有效性检查和

shared_ptr

登录后复制

的获取。

std::shared_ptr<int> sharedPtrFromWeak = weakPtr.lock();
if (sharedPtrFromWeak) {
    std::cout << "Value: " << *sharedPtrFromWeak << std::endl;
} else {
    std::cout << "Object no longer exists." << std::endl;
}

登录后复制

何时应该使用 C++

weak_ptr

登录后复制

？

weak_ptr

登录后复制

在解决循环引用问题上非常有用。循环引用发生在两个或多个对象彼此持有

shared_ptr

登录后复制

，导致它们的引用计数永远不会降为零，从而造成内存泄漏。

例如，考虑一个父子关系：

C知道

CSDN推出的一款AI技术问答工具

查看详情

#include <iostream>
#include <memory>

class Child; // 前向声明

class Parent {
public:
    std::shared_ptr<Child> child;
    ~Parent() { std::cout << "Parent destroyed" << std::endl; }
};

class Child {
public:
    std::shared_ptr<Parent> parent;
    ~Child() { std::cout << "Child destroyed" << std::endl; }
};

int main() {
    std::shared_ptr<Parent> parent = std::make_shared<Parent>();
    std::shared_ptr<Child> child = std::make_shared<Child>();

    parent->child = child;
    child->parent = parent; // 循环引用

    return 0; // Parent 和 Child 都不会被销毁
}

登录后复制

在这个例子中，

Parent

登录后复制

持有一个指向

Child

登录后复制

的

shared_ptr

登录后复制

，而

Child

登录后复制

持有一个指向

Parent

登录后复制

的

shared_ptr

登录后复制

。当

Parent

登录后复制

和

Child

登录后复制

超出作用域时，它们的析构函数不会被调用，因为它们的引用计数都为 1。

要解决这个问题，可以将

Child

登录后复制

类中的

Parent

登录后复制

成员改为

weak_ptr

登录后复制

：

#include <iostream>
#include <memory>

class Child;

class Parent {
public:
    std::shared_ptr<Child> child;
    ~Parent() { std::cout << "Parent destroyed" << std::endl; }
};

class Child {
public:
    std::weak_ptr<Parent> parent; // 使用 weak_ptr
    ~Child() { std::cout << "Child destroyed" << std::endl; }
};

int main() {
    std::shared_ptr<Parent> parent = std::make_shared<Parent>();
    std::shared_ptr<Child> child = std::make_shared<Child>();

    parent->child = child;
    child->parent = parent;

    return 0; // Parent 和 Child 都会被销毁
}

登录后复制

现在，

Child

登录后复制

不再拥有

Parent

登录后复制

的所有权，因此当

Parent

登录后复制

超出作用域时，它的引用计数降为 0，可以被销毁。

Child

登录后复制

的析构函数也会被调用，从而避免了内存泄漏。

weak_ptr

登录后复制

在多线程环境中的应用

在多线程环境中，

weak_ptr

登录后复制

的有效性检查和

shared_ptr

登录后复制

的获取需要原子性。

lock()

登录后复制

方法已经提供了这种原子性，因此它是线程安全的。

#include <iostream>
#include <memory>
#include <thread>

int main() {
    std::shared_ptr<int> sharedPtr = std::make_shared<int>(42);
    std::weak_ptr<int> weakPtr = sharedPtr;

    std::thread t([weakPtr]() {
        std::shared_ptr<int> sharedPtrFromWeak = weakPtr.lock();
        if (sharedPtrFromWeak) {
            std::cout << "Thread: Value: " << *sharedPtrFromWeak << std::endl;
        } else {
            std::cout << "Thread: Object no longer exists." << std::endl;
        }
    });

    sharedPtr.reset(); // 主线程释放 shared_ptr

    t.join();

    return 0;
}

登录后复制

在这个例子中，主线程释放了