weak_ptr的作用及应用场景——shared_ptr的循环引用问题

weak_ptr 是为了辅助shared_ptr而引入的一种智能指针,它存在的意义就是协助shared_ptr更好的完成工作,我们可以把它比做成一个秘书或助理。

weak_ptr的构造和析构并不会改变引用计数的大小,它可以由一个shared_ptr或weak_ptr的对象构造获得。它没有对“*”和“->”的重载,但可以使用lock获得一个可用的shared_ptr对象。

当面试官问到weak_ptr智能指针的时候,你可以举出一个场景来说明它的作用

场景--------------解决shared_ptr的循环引用问题

我们知道,智能指针shared_ptr采用的是引用计数的方式,下面我们来写一个双向链表。

#include<iostream>
#include<boost/shared_ptr.hpp>
#include<boost/weak_ptr.hpp>

using namespace std;

struct Node
{
	int _data;
	boost::shared_ptr<Node> _next;
	boost::shared_ptr<Node> _prev;
};

int main()
{
	boost::shared_ptr<Node> sp1(new Node);
	boost::shared_ptr<Node> sp2(new Node);
	sp1->_next = sp2;
	sp2->_prev = sp1;
	system("pause");
	return 0;
}

我们暂且将这两块空间称为Node1,和Node2,。我们从上述代码中可知,sp1,sp2,_next,_prev均为shared_ptr类型的智能指针。sp1与sp2->prev都指向Node1,所以sp1的引用计数为2,同理sp1->_next与sp2都指向Node2,所以sp2的引用计数也为2。这是前提,注意,问题来了。




当我们想销毁这个链表或者说销毁一个结点的时候,我们需要将引用计数置为1,假如,我们要delete sp2这块空间,我们需要将sp2的引用计数置为1,就是说我们需要将sp1->_next这个指针销毁掉。把sp2->_next销毁, 就意味着先要把sp1销毁。

如果想把sp1销毁,就要把sp1的引用计数置为1,所以,我们就要把sp2->_prev销毁,要想把sp2->_prev销毁,就代表先要把sp2销毁。

这样一来,我们就陷入了一个无限的循环当中。



这就是所谓的 shared_ptr智能指针的循环引用问题。


我们如何用weak_ptr来解决这个场景呢?

解决:

    

#include<iostream>
#include<boost/shared_ptr.hpp>
#include<boost/weak_ptr.hpp>

using namespace std;

struct Node
{
	int _data;
	boost::weak_ptr<Node> _next;
	boost::weak_ptr<Node> _prev;
	//boost::shared_ptr<Node> _next;
	//boost::shared_ptr<Node> _prev;
};

int main()
{
	boost::shared_ptr<Node> sp1(new Node);
	boost::shared_ptr<Node> sp2(new Node);
	sp1->_next = sp2;
	sp2->_prev = sp1;
	system("pause");
	return 0;
}

只需要把Node结点里面的指针定义为weak_ptr类型就好,weak_ptr的构造析构不会影响引用计数的大小,当我们采用这种方式时,sp1和sp2的引用计数始终为1,当我们想销毁时就可以随意操作啦!

当面试官问道你关于,shared _ptr 的循环引用问题或者weak_ptr时,你只需要将这个场景描述给他,就可以轻松的把这道题拿下了,祝你好运!

  • 8
    点赞
  • 12
    收藏
    觉得还不错? 一键收藏
  • 3
    评论
在 C++ 中,shared_ptr 常常被用来管理动态分配的资源。然而,当多个 shared_ptr 相互引用时,就会出现循环引用问题,导致内存泄漏。为了解决这个问题,C++11 引入了 weak_ptrweak_ptrshared_ptr 的一种扩展,它可以指向一个由 shared_ptr 管理的对象,但并不拥有该对象的所有权。weak_ptr 可以被用来解决 shared_ptr 循环引用问题。 当一个对象被多个 shared_ptr 共享时,每一个 shared_ptr 都会增加该对象的引用计数。如果其中一个 shared_ptr 被销毁时,该对象的引用计数会减少。但如果多个 shared_ptr 相互引用,就会导致循环引用问题。例如: ```c++ class B; class A { public: std::shared_ptr<B> b_ptr; }; class B { public: std::shared_ptr<A> a_ptr; }; int main() { std::shared_ptr<A> a(new A); std::shared_ptr<B> b(new B); a->b_ptr = b; b->a_ptr = a; return 0; } ``` 在上面的代码中,A 和 B 互相引用,它们的引用计数永远不会为 0,导致内存泄漏。为了解决这个问题,我们可以将其中一个 shared_ptr 改为 weak_ptr。例如: ```c++ class B; class A { public: std::weak_ptr<B> b_ptr; }; class B { public: std::shared_ptr<A> a_ptr; }; int main() { std::shared_ptr<A> a(new A); std::shared_ptr<B> b(new B); a->b_ptr = b; b->a_ptr = a; return 0; } ``` 在这个例子中,A 持有一个指向 B 的 weak_ptr,而 B 持有一个指向 A 的 shared_ptr。这样,当 A 或 B 中的任意一个 shared_ptr 被销毁时,它们所指向的对象的引用计数都会减少,从而解决了循环引用问题。 需要注意的是,当通过 weak_ptr 访问对象时,需要先将 weak_ptr 转换为 shared_ptr,否则无法访问对象。假设上面的例子中,我们需要访问 B 对象,可以这样做: ```c++ std::shared_ptr<B> b_ptr = a->b_ptr.lock(); if (b_ptr) { // 访问 B 对象的成员 } ``` 在上面的代码中,我们使用 lock() 方法将 weak_ptr 转换为 shared_ptr,如果转换成功,就可以访问 B 对象的成员了。 总之,weak_ptrshared_ptr 的一种扩展,可以用来解决 shared_ptr 循环引用问题。通过将其中一个 shared_ptr 改为 weak_ptr,可以防止循环引用导致的内存泄漏。
评论 3
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值