shared_ptr循环引用

`shared_ptr`循环引用是指两个或多个`shared_ptr`对象互相持有对方所管理的对象的指针，导致这些对象无法被正确释放，从而造成内存泄漏。

例如，假设有两个类`A`和`B`，它们分别持有对方的`shared_ptr`：

class A {
public:
    std::shared_ptr<B> b_ptr;
};

class B {
public:
    std::shared_ptr<A> a_ptr;
};

当`A`和`B`的对象相互引用时，它们的引用计数都不会降为0，因此它们所占用的内存无法被正确释放，造成内存泄漏。

为了避免`shared_ptr`循环引用，可以使用`weak_ptr`来打破循环引用关系。例如，可以将`B`类中的`shared_ptr`改为`weak_ptr`：

class B {
public:
    std::weak_ptr<A> a_ptr;
};

这样，在`A`和`B`的对象相互引用时，它们所管理的对象的引用计数会正确地降为0，从而释放所占用的内存。

相关问题

c++ shared_ptr循环引用

shared_ptr循环引用是指多个shared_ptr实例互相引用，导致对象无法被释放的情况。shared_ptr采用引用计数的智能指针，可以指向同一个动态对象，并维护了一个共享的引用计数器。当多个shared_ptr实例相互引用时，它们的引用计数无法降为零，从而导致内存泄漏。
为了解决shared_ptr引起的循环引用问题，可以使用weak_ptr指针。weak_ptr是一种弱引用，不能单独使用，只能配合shared_ptr使用。相比之下，weak_ptr并不增加引用计数，它只是提供了对被共享对象的一个非拥有的引用。通过使用weak_ptr，可以打破shared_ptr之间的循环引用，使对象能够正常释放。
在C++中，我们可以使用weak_ptr的lock()函数来获取一个可用的shared_ptr对象，从而访问被共享对象的成员函数和成员变量。weak_ptr没有重载*和->运算符，因此无法直接访问对象，但可以使用lock()函数来获取shared_ptr，并通过该shared_ptr来访问对象的成员。
通过使用weak_ptr解决shared_ptr循环引用问题，可以避免内存泄漏和资源占用过多的情况。<span class="em">1</span><span class="em">2</span><span class="em">3</span>
#### 引用[.reference_title]
- *1* [C++11智能指针之weak_ptr详解](https://download.csdn.net/download/weixin_38740201/14841441)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 33.333333333333336%"]
- *2* [C++ 智能指针的循环引用问题](https://blog.csdn.net/qq_28584889/article/details/88726324)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 33.333333333333336%"]
- *3* [C++智能指针(share_ptr)及其循环引用问题](https://blog.csdn.net/feikudai8460/article/details/104747490)[target="_blank" data-report-click={"spm":"1018.2226.3001.9630","extra":{"utm_source":"vip_chatgpt_common_search_pc_result","utm_medium":"distribute.pc_search_result.none-task-cask-2~all~insert_cask~default-1-null.142^v93^chatsearchT3_2"}}] [.reference_item style="max-width: 33.333333333333336%"]
[ .reference_list ]

shared_ptr循环引用举例

假设有两个类A和B，类A有一个指向类B的shared_ptr，而类B也有一个指向类A的shared_ptr，这就形成了循环引用。

示例代码：

class B;

class A {
public:
    shared_ptr<B> b_ptr;
};

class B {
public:
    shared_ptr<A> a_ptr;
};

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

在这个例子中，当a和b的引用计数都变为0时，它们所指向的对象将不会被销毁，从而导致内存泄漏。

为了避免这种情况，可以使用weak_ptr来打破循环引用，例如：

class B;

class A {
public:
    weak_ptr<B> b_ptr;
};

class B {
public:
    weak_ptr<A> a_ptr;
};

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

这样当a和b的引用计数都变为0时，它们所指向的对象将会被正确地销毁。