标准库里的weak_ptr如何解决循环引用所带来的问题

ゝ一世哀愁。 2022-06-18 09:45 353阅读 0赞

使用weak\_ptr解决循环引用的方法

#include<iostream>
    #include<memory>
    #include<stdlib.h>
    using namespace std;
    template<class T>
    class Node
    {
    public:
        Node(T num)
            :value(num)
        {
    
        }
        ~Node()
        {
            cout << "~Node()" << endl;
        }
        weak_ptr<Node> pNext; //使用弱引用打破循环引用
        weak_ptr<Node> pPre;
        T value;
    };
    void FunTest()
    {
        shared_ptr<Node<int>> p1(new Node<int>(1));
        shared_ptr<Node<int>> p2(new Node<int>(2));
        p1->pNext = p2;
        p2->pPre = p1;
    }
    int main()
    {
        FunTest();
        system("pause");
        return 0;
    }

下面重点剖析C++标准库中的具体操作  
要new出一个对象的空间那么先去调用构造函数再来使用operator new 开辟空间：

new Node<int>(1) 先去调用Node的构造函数由于类里有weak_ptr的对象因此也要调用weak_ptr的构造
    weak_ptr<Node> pNext;
    weak_ptr<Node> pPre;
    那么也要首先pNext构造出来：调用weak_ptr的构造函数
    class weak_ptr: public _Ptr_base<_Ty>  继承自_Ptr_base自然要调用_Ptr_base的构造函数
    weak_ptr() _NOEXCEPT
        {   // construct empty weak_ptr object
        }
        _Ptr_base()
        : _Ptr(0), _Rep(0)
        {   // construct
        }
       _Ptr_base类里的数据成员
       _Ty *_Ptr;  //原生态指针管理结点的空间
       _Ref_count_base *_Rep;  //管理引用计数的空间

构造pPre也是同理  
将weak\_ptr的对象构造完成之后，此时结点构造完成之后再将这个结点交给shared\_ptr这个对象去管理  
调用shared\_ptr的构造函数

explicit shared_ptr(_Ux *_Px)
            {   // construct shared_ptr object that owns _Px
            _Resetp(_Px);
            }
    shared_ptr继承_Ptr_base()因此也会去调用_Ptr_base的构造函数 
    _Ptr_base()
            : _Ptr(0), _Rep(0) { // construct }

调用完构造函数之后在执行shared\_ptr中的\_Resetp(\_Px)函数，  
进入\_Resetp(\_Px)这个函数

void _Resetp(_Ux *_Px)
            {   // release, take ownership of _Px
            _TRY_BEGIN  // allocate control block and reset
            _Resetp0(_Px, new _Ref_count<_Ux>(_Px));
            _CATCH_ALL  // allocation failed, delete resource
            delete _Px;
            _RERAISE;
            _CATCH_END
            }

发现动态的开辟了管理引用计数的空间  
\_Resetp0(\_Px, new \_Ref\_count<\_Ux>(\_Px));先将参数创建出来，那么势必要调用\_Ref\_count的构造函数

class _Ref_count
        : public _Ref_count_base
        {   // handle reference counting for object without deleter
    public:
        _Ref_count(_Ty *_Px)
            : _Ref_count_base(), _Ptr(_Px)
            {   // construct
            }

由于\_Ref\_count这个类是继承自\_Ref\_count\_base因此调用\_Ref\_count\_base这个类的构造函数

_Ref_count_base()
            {   // construct
            _Init_atomic_counter(_Uses, 1);
            _Init_atomic_counter(_Weaks, 1);
            }

将引用计数use\_count和weak\_count都初始化为1  
此时空间开辟完成之后再次回到\_Resetp0(\_Px, new \_Ref\_count<\_Ux>(\_Px))进入这个函数体

void _Resetp0(_Ux *_Px, _Ref_count_base *_Rx)
            {   // release resource and take ownership of _Px
            this->_Reset0(_Px, _Rx);
            _Enable_shared(_Px, _Rx);
            }
        };

接下来进入void \_Reset0(\_Ty \*\_Other\_ptr, \_Ref\_count\_base \*\_Other\_rep)这个函数体内，开辟出的节点的空间和引用计数的空间赋过去

void _Reset0(_Ty *_Other_ptr, _Ref_count_base *_Other_rep)
            {   // release resource and take new resource
            if (_Rep != 0)
                _Rep->_Decref();
            _Rep = _Other_rep;
            _Ptr = _Other_ptr;
            }

上述操作则将所需的所有空间都开辟完成并完成了初始化工作

接下来是对这两步进行解析

p1->pNext = p2;
    p2->pPre = p1;

使用这个赋值因为是将p2赋值给p1->Pnext

template<class _Ty2>
            weak_ptr& operator=(const shared_ptr<_Ty2>& _Right) _NOEXCEPT
            {   // assign from _Right
            this->_Resetw(_Right);
            return (*this);
    }

void _Resetw(const _Ptr_base<_Ty2>& _Other)
            {   // release weak reference to resource and take _Other._Ptr
            _Resetw(_Other._Ptr, _Other._Rep);
            }

void _Resetw(_Ty2 *_Other_ptr, _Ref_count_base *_Other_rep)
        {   // point to _Other_ptr through _Other_rep
        if (_Other_rep)
            _Other_rep->_Incwref();
        if (_Rep != 0)
            _Rep->_Decwref();
        _Rep = _Other_rep;
        _Ptr = _Other_ptr;
        }

void _Incwref()//增加引用计数
            {   // increment weak reference count
            _MT_INCR(_Mtx, _Weaks);

注意将p2赋值给p1->pNext是增加了p1的引用计数。  
p2->pPre = p1;也是上述操作同理,将p1赋值给p2->pPre是增加了p2的引用计数

重点剖析析构的过程：

进行析构  
先调用~shared\_ptr析构p2这个对象

~shared_ptr() _NOEXCEPT
        {   // release resource
        this->_Decref();
        }
    
      通过this->_Decref();进入以下操作
        void _Decref()
        {   // decrement reference count
        if (_Rep != 0) //专门管理引用计数的空间
            _Rep->_Decref();
        }

此时引用计数的空间肯定不空 进入\_Rep->\_Decref();

void _Decref()
            {   // decrement use count
            if (_MT_DECR(_Mtx, _Uses) == 0)
                {   // destroy managed resource, decrement weak reference count
                _Destroy();
                _Decwref();
                }
            }

先进入\_Destroy()这个函数

virtual void _Destroy()
            {   // destroy managed resource
            delete _Ptr;
            }

释放这个p2节点的空间operator delete之前先去调用Node的析构函数   
    ~Node()
    {
        cout << "~Node()" << endl;
    }

在这个析构函数里\}接下来释放p2的pPre

~weak_ptr() _NOEXCEPT
            {   // release resource
            this->_Decwref();
            }

通过 this->\_Decwref()进入 \_Decwref()这个函数

void _Decwref()
            {   // decrement weak reference count
            if (_Rep != 0)
                _Rep->_Decwref();
            }

通过\_Rep->\_Decwref();进入\_Rep的\_Decewref函数里

void _Decwref()
            {   // decrement weak reference count
            if (_MT_DECR(_Mtx, _Weaks) == 0)
                _Delete_this();
            }

由于p2->pPre=p1因此减少的是p1的weak，但p1的–weak并不为0因此不能执行\_Delete\_this();

接下来继续释放p2的pNext

~weak_ptr() _NOEXCEPT
            {   // release resource
            this->_Decwref();
            }

p2的pNext为空则进不去 \_Rep->\_Decwref();

void _Decwref()
            {   // decrement weak reference count
            if (_Rep != 0)
                _Rep->_Decwref();
                }

p2的pNex为NULL直接退出这个函数返回到这个函数里，释放p2时Destory()这个函数就执行完毕了接下来继续 执行void \_Decwref()

void _Decref()
            {   // decrement use count
            if (_MT_DECR(_Mtx, _Uses) == 0)
                {   // destroy managed resource, decrement weak reference count
                _Destroy();
                _Decwref();
                }
            }

释放p2时Destory()这个函数就执行完毕了接下来继续执行void \_Decwref()这个函数由于p2的– weakcount不等于0，不能进入\_Delete\_this();这个函数里因此不能释放p2的引用计数的空间

void _Decwref()
            {   // decrement weak reference count
            if (_MT_DECR(_Mtx, _Weaks) == 0)
                _Delete_this();
            }

接下来释放p1这个结点也是同理，因为p1是一个shared\_ptr的对象，因此先去调用shared\_ptr的析构函数

~shared_ptr() _NOEXCEPT
        {   // release resource
        this->_Decref();
        }
        void _Decref()
        {   // decrement reference count
        if (_Rep != 0) //专门管理引用计数的空间
            _Rep->_Decref();
        }

因为p2引用计数的空间是不空的，因此进入释放资源减少引用计数的的过程：

void _Decref()
            {   // decrement use count
            if (_MT_DECR(_Mtx, _Uses) == 0)    //将p1的--use_count等于0进入下面的语句中
                {   // destroy managed resource, decrement weak reference count
                _Destroy();
                _Decwref();
                }
            }

先进入\_Destroy()这个函数

virtual void _Destroy()
            {   // destroy managed resource
            delete _Ptr;
            }

释放\_Ptr这个原生态指针所管理的结点的空间  
释放这个p1节点的空间operator delete之前先去调用Node的析构函数

~Node()
        {
            cout << "~Node()" << endl;
        }

由于这个结点里还存在两个weak\_ptr类型的对象，因此要继续调用~weak\_ptr()这个函数在这个析构函数里\}接下来释放p1的pPre

~weak_ptr() _NOEXCEPT
            {   // release resource
            this->_Decwref();
            }

接下来进入到\_Decwref()这个函数里面去，由于p1的pPre为空的因此直接就退出当前的函数了

void _Decwref()
            {   // decrement weak reference count
            if (_Rep != 0)
                _Rep->_Decwref();
            }

接下来继续释放p1的pNext

~weak_ptr() _NOEXCEPT
            {   // release resource
            this->_Decwref();
            }

由于p1的pNext是不空的接下来就计入到以下语句

void _Decwref()
            {   // decrement weak reference count
            if (_Rep != 0)
                _Rep->_Decwref();
            }

由于p1的pNext是指向p2的，因此–weak是减少的p2的weak

void _Decwref()
            {   // decrement weak reference count
            if (_MT_DECR(_Mtx, _Weaks) == 0)
                _Delete_this();
            }

此时p2的weak\_count是等于0的因此可以进入以下语句

virtual void _Delete_this()
            {   // destroy self
            delete this;
            }

因此p2的引用计数的空间就被释放掉了

此时p1的 \_Decref()函数中的\_Destroy()函数中所有的语句都执行完成了，因此再去执行\_Decwref()这个函数

void _Decref()
            {   // decrement use count
            if (_MT_DECR(_Mtx, _Uses) == 0)    //将p1的--use_count等于0进入下面的语句中
                {   // destroy managed resource, decrement weak reference count
                _Destroy();
                _Decwref();
                }
            }

void _Decwref()
            {   // decrement weak reference count
            if (_MT_DECR(_Mtx, _Weaks) == 0)
                _Delete_this();
            }

此时p1的–weak\_count等于0进入\_Delete\_this();这个函数

virtual void _Delete_this()
            {   // destroy self
            delete this;
            }

因此p1的引用计数的空间也就被释放了

至此p1和p2两个结点中所有的资源都被释放了，解决了循环引用所带来的问题。构建一个节点两次new两次delete并没有发生内存泄漏解决了循环引用所带来的问题。

发表评论取消回复

表情：

评论列表（有 0 条评论，353人围观）

还没有评论，来说两句吧...

相关阅读

相关在Java中如何解决循环引用导致的问题

在Java中，循环引用通常是指两个或者更多的对象相互持有对方的引用，形成了一个互相依赖的链。这种结构可能会导致内存泄漏、应用性能下降等问题。以下是一些解决循环引用问题的方法

小灰灰/ 2024年12月12日 04:24/ 0 赞/ 58 阅读

相关 Java标准库升级带来的影响：如何平稳地升级Java标准库并应对问题？

Java标准库（Java Standard Library）是Java语言的核心组成部分，提供了大量用于文件操作、网络编程、数据结构、并发编程等的类和接口。随着Java版本的更

冷不防/ 2024年11月07日 10:00/ 0 赞/ 53 阅读

相关如何理解并解决Java中的循环引用问题

循环引用在Java中是指两个或更多的对象相互持有对方的引用，形成了一个互相依赖的循环结构。例如，有两棵树A和B，它们都有根节点，A的根指向B，B的根指向A。这在编程中就构成

迈不过友情╰/ 2024年10月22日 23:03/ 0 赞/ 80 阅读

相关如何解决Java中的循环引用问题案例

在Java中，循环引用是指两个或更多的对象相互引用，形成一个无法解开的循环。这种问题通常出现在设计模式如单例、观察者等时。解决循环引用的问题案例： 1. **使用弱引用*

小灰灰/ 2024年10月17日 16:21/ 0 赞/ 72 阅读

相关关于EventTime所带来的问题

在Flink中，EventTime即事件时间，能够反映事件在某个时间点发生的真实情况，即使在任务重跑情况也能够被还原，计算某一段时间内的数据，那么只需要将EventTime范围

我就是我/ 2023年02月27日 13:38/ 0 赞/ 51 阅读

相关怎么解决引用计数 GC 的循环引用问题？

> 引用计数方式 GC 存在循环引用问题，导致无法辨别无用对象，而 GC ROOT 方式不存在循环引用的问题引用计数和 GC ROOT 的实现机理很易理解，面试时大家都能流

分手后的思念是犯贱/ 2022年12月22日 09:53/ 0 赞/ 213 阅读

相关线程共享所带来的问题

假设两个线程共享一个计数变量，线程1对计数变量自增5000，线程2对计数变量自减5000，最终的结果是0吗？不一定，会发生`线程不安全`问题。 import lo

我就是我/ 2022年12月02日 04:15/ 0 赞/ 178 阅读

相关解决一个国际化标准库的问题

解决一个国际化标准库的问题参考文章： [（1）解决一个国际化标准库的问题][1] （2）https://www.cnblogs.com/xiaoCon/p/314771

我就是我/ 2022年09月05日 05:17/ 0 赞/ 254 阅读

相关标准库里的weak_ptr如何解决循环引用所带来的问题

使用weak\_ptr解决循环引用的方法 include<iostream> include<memory> include<stdlib.h>

ゝ一世哀愁。/ 2022年06月18日 09:45/ 0 赞/ 354 阅读

相关 flask-sqlalchemy 循环引用问题如何解决?(转载)

相信很多新手朋友在使用flask\_sqlalchemy时，都会遇到循环引用问题（截图如下）　　![70][] 　　为了方便大家理解flask\_sqlalchemy循环

矫情吗；*/ 2022年02月04日 18:59/ 0 赞/ 455 阅读