C++ std::shared_ptr 与 std::weak_ptr 详解

C++ std::shared_ptr 与 std::weak_ptr 详解

std::shared_ptr

std::shared_ptr 是 C++11 引入的智能指针之一，用于管理动态分配的对象的生命周期。它通过引用计数来管理对象的内存，当最后一个 std::shared_ptr 指向的对象被销毁时，自动释放内存

基本概念

• 引用计数：std::shared_ptr 内部维护一个引用计数器，记录有多少个 std::shared_ptr 实例共享同一个对象。当一个新的 std::shared_ptr 被复制时，引用计数增加；当一个 std::shared_ptr 被销毁时，引用计数减少。当引用计数变为零时，所管理的对象会被自动删除。
• 线程安全：std::shared_ptr 的引用计数操作是线程安全的，但对象的其他操作需要用户自己保证线程安全。

使用方法

1. 创建 std::shared_ptr

#include <memory>
#include <iostream>

class MyClass {
public:
    MyClass() { std::cout << "MyClass Constructor" << std::endl; }
    ~MyClass() { std::cout << "MyClass Destructor" << std::endl; }
};

int main() {
    std::shared_ptr<MyClass> ptr1 = std::make_shared<MyClass>(); // 推荐的创建方式
    {
        std::shared_ptr<MyClass> ptr2 = ptr1; // 引用计数增加
        std::cout << "ptr2 goes out of scope" << std::endl;
    } // ptr2 被销毁，引用计数减少
    std::cout << "ptr1 goes out of scope" << std::endl;
    return 0;
} // ptr1 被销毁，引用计数变为零，对象被删除

2. 访问对象

std::shared_ptr<MyClass> ptr = std::make_shared<MyClass>();
ptr->someMethod(); // 使用箭头操作符访问对象的方法
(*ptr).someMethod(); // 使用解引用操作符访问对象的方法

3. 传递 std::shared_ptr

void process(std::shared_ptr<MyClass> ptr) {
    // 函数内部使用 ptr
}

int main() {
    std::shared_ptr<MyClass> ptr = std::make_shared<MyClass>();
    process(ptr); // 传递 shared_ptr，引用计数增加
}

常见问题

1. 循环引用：如果两个对象互相持有 std::shared_ptr，会导致循环引用，引用计数永远不会变为零，导致内存泄漏。解决方法是使用 std::weak_ptr。
2. 性能开销：std::shared_ptr 的引用计数操作有一定的性能开销，特别是在多线程环境下。

std::weak_ptr (解决循环引用问题)

在使用 std::shared_ptr 时，循环引用是一个常见的问题。循环引用会导致引用计数永远不会变为零，从而导致内存泄漏。为了解决这个问题，可以使用 std::weak_ptr。
std::weak_ptr 是一种不增加引用计数的智能指针，它可以安全地引用一个由 std::shared_ptr 管理的对象。std::weak_ptr 不能直接访问对象，需要通过 lock() 方法将其转换为 std::shared_ptr。

示例代码

假设我们有两个类 A 和 B，它们互相引用对方：

#include <iostream>
#include <memory>

class B; // 前向声明

class A {
public:
    std::shared_ptr<B> b_ptr;
    ~A() { std::cout << "A destroyed" << std::endl; }
};

class B {
public:
    std::shared_ptr<A> a_ptr;
    ~B() { std::cout << "B destroyed" << std::endl; }
};

int main() {
    auto a = std::make_shared<A>();
    auto b = std::make_shared<B>();
    a->b_ptr = b;
    b->a_ptr = a;
    return 0;
}

在上述代码中，A 和 B 互相持有 std::shared_ptr，会导致循环引用，A 和 B 都不会被销毁。

使用 std::weak_ptr 解决循环引用

我们可以将其中一个类的 std::shared_ptr 改为 std::weak_ptr：

#include <iostream>
#include <memory>

class B; // 前向声明

class A {
public:
    std::shared_ptr<B> b_ptr;
    ~A() { std::cout << "A destroyed" << std::endl; }
};

class B {
public:
    std::weak_ptr<A> a_ptr; // 改为 std::weak_ptr
    ~B() { std::cout << "B destroyed" << std::endl; }
};

int main() {
    auto a = std::make_shared<A>();
    auto b = std::make_shared<B>();
    a->b_ptr = b;
    b->a_ptr = a;
    return 0;
}

在这个修改后的代码中，B 持有 A 的 std::weak_ptr，这样就不会增加 A 的引用计数，从而避免了循环引用

访问 std::weak_ptr 指向的对象

要访问 std::weak_ptr 指向的对象，需要使用 lock() 方法将其转换为 std::shared_ptr：

if (auto a_shared = b->a_ptr.lock()) {
    // 安全地使用 a_shared
}

这样可以确保在访问对象时，它仍然是有效的。