C++智能指针:weak_ptr实现详解

编程语言:C++ 同时被 2 个专栏收录
64 篇文章 1 订阅
104 篇文章 0 订阅

weak_ptr描述

声明

头文件:<memory>
模版类:template <class T> class weak_ptr
声明方式:std::weak_ptr<type_id> statement

作用

根据boost库的官方描述,weak_ptr是由shared_ptr管理的一种弱引用对象的模版类。weak_ptr的对象能够使用shared_ptr指针的构造函数转换为一个shared_ptr对象。但是这里shared_ptr的构造函数参数需要包含weak_ptr的lock成员,该成员是weak_ptr用来获取shared_ptr的指针。

这样当shared_ptr在多线程过程中被销毁时shared_ptr::reset,weak_ptr的lock成员仍然能够保留shared_ptr的成员,直到当前shared_ptr正常终止,否则会出现非常危险的内存泄漏。关于lock()成员的作用如下描述:
如下代码

shared_ptr<int> p(new int(5));
weak_ptr<int> q(p);

// some time later

if(int * r = q.get()) 
{
    // use *r
}

多线程环境中shared_ptr是可以被多个线程共享,在r被使用之前p对象执行了p.reset(),正如我们上一篇文章中对shared_ptr的描述(C++智能指针:shared_ptr 实现详解),reset成员会重置当前shared_ptr指针的指向。此时,当前线程如果继续使用r指针,势必会产生访问空地址的异常问题

根据以上问题,使用weak_ptr::lock()成员来解决该问题

shared_ptr<int> p(new int(5));
weak_ptr<int> q(p);

// some time later

//使用weak_ptr的lock成员来获取shared_ptr的指针
if(shared_ptr<int> r = q.lock())
{
    // use *r
}

关于lock()成员简单说明一下,lock成员获取到的shared_ptr p指针创建一个临时对象(我们weak_ptr弱引用的体现),这个临时对象同样指向p,即使p执了reset这样的delete引用的操作,弱引用对象仍然持有改智能指针的地址,直到r指针的生命周期结束才会释放。不得不佩服C++语言设计者的脑洞,为了保持C++对内存操作的自由,即使耗费再大的精力也要实现这一目标,工匠精神才让今天的C++越来越被底层程序员喜欢。

原理实现

源码文件/boost/smart_ptr/weak_ptr.hpp

template<class T> class weak_ptr
{
private:

    // Borland 5.5.1 specific workarounds
    typedef weak_ptr<T> this_type;
  • constructor 构造函数
    //默认构造函数
    weak_ptr() BOOST_NOEXCEPT : px(0), pn() // never throws in 1.30+
    {
    }
    
    //拷贝构造函数
    weak_ptr( weak_ptr const & r ) BOOST_NOEXCEPT : px( r.px ), pn( r.pn )
    {
    }
    
  • destructor析构函数,这里weak_ptr使用的是默认析构函数,一般使用expired返回空对象或者user_count()为0的情况则辅助shared_ptr释放引用
  • operator=
    1. 
     weak_ptr & operator=( weak_ptr && r ) BOOST_NOEXCEPT
    {
        this_type( static_cast< weak_ptr && >( r ) ).swap( *this );
        return *this;
    }
    
    //2.这里会更加安全,使用lock成员获取Y类型的指针
    template<class Y>
    weak_ptr & operator=( weak_ptr<Y> const & r ) BOOST_NOEXCEPT
    {
        boost::detail::sp_assert_convertible< Y, T >();
    
        px = r.lock().get();
        pn = r.pn;
    
        return *this;
    }
    
    3.
    template<class Y>
    weak_ptr & operator=( shared_ptr<Y> const & r ) BOOST_NOEXCEPT
    {
        boost::detail::sp_assert_convertible< Y, T >();
    
        px = r.px;
        pn = r.pn;
    
        return *this;
    }
    
  • weak_ptr::swap成员,交换两个weak_ptr所指内容以及地址
     void swap(this_type & other) BOOST_NOEXCEPT
    {
    	//先交换地址,再交换内容
        std::swap(px, other.px);
        pn.swap(other.pn);
    }
    
  • weak_ptr::reset成员,·重新指定对象地址和内容,就像是重新使用默认构造函数进行了初始化
    void reset() BOOST_NOEXCEPT // never throws in 1.30+
    {
    	//使用默认构造函数构造的对象和当前对象进行swap操作
        this_type().swap(*this);
    }
    
  • weak_ptr::use_count成员,获取shared_ptr对象被引用的次数。如果为空,则返回0
    long use_count() const BOOST_NOEXCEPT
    {
        return pn.use_count();
    }
    
  • weak_ptr::expired成员,当根据use_count==0来返回bool,其返回为true的时候,使用lock获取weak_ptr的指针只能获取到空指针
     bool expired() const BOOST_NOEXCEPT
    {
        return pn.use_count() == 0;
    }
    
  • weak_ptr::lock成员,会向weak_ptr对象返回一个shared_ptr。正如我们之前在weak_ptr作用中所描述的,防止多线程访问时的shared_ptr内存泄漏。此时weak_ptr对象获取到的指针为临时指针,会指向shared_ptr对象之前所指向的地址。
    shared_ptr<T> lock() const BOOST_NOEXCEPT
    {
        return shared_ptr<T>( *this, boost::detail::sp_nothrow_tag() );
    }
    

函数成员使用

  • 构造函数
    #include <iostream>
    #include <memory>
    
    struct C {int* data;};
    
    int main () {
      std::shared_ptr<int> sp (new int);
    
      std::weak_ptr<int> wp1;
      std::weak_ptr<int> wp2 (wp1);
      std::weak_ptr<int> wp3 (sp);
    
      std::cout << "use_count:\n";
      
      //weak_ptr对象如果为经shared_ptr初始化,
      //它是没有引用计数的,所以这里wp1和wp2引用计数都为0
      //只有wp3经过了shared_ptr初始化,它的引用计数才为1
      
      std::cout << "wp1: " << wp1.use_count() << '\n';
      std::cout << "wp2: " << wp2.use_count() << '\n';
      std::cout << "wp3: " << wp3.use_count() << '\n';
      
      return 0;
    }
    
    输出如下:
    use_count:
    wp1: 0
    wp2: 0
    wp3: 1
    
  • weak_ptr::operator=赋值运算符
    // weak_ptr::operator= example
    #include <iostream>
    #include <memory>
    
    int main () {
      std::shared_ptr<int> sp1,sp2;
      std::weak_ptr<int> wp;
                                           // sharing group:
                                           // --------------
      sp1 = std::make_shared<int> (10);    // sp1
      wp = sp1;                            // sp1, wp
    
      sp2 = wp.lock();                     // sp1, wp, sp2
      sp1.reset();                         //      wp, sp2
    
      //通过lock保留的临时指针,重新获取到了shared_ptr共享的地址
      sp1 = wp.lock();                     // sp1, wp, sp2
    
      std::cout << "*sp1: " << *sp1 << '\n';
      std::cout << "*sp2: " << *sp2 << '\n';
    
      return 0;
    }
    
    输出如下
    *sp1: 10
    *sp2: 10
    
  • std::weak_ptr::swap交换指针地址以及对应的内容
    #include <iostream>
    #include <memory>
    
    int main () {
      std::shared_ptr<int> sp1 (new int(10));
      std::shared_ptr<int> sp2 (new int(20));
    
      std::weak_ptr<int> wp1(sp1);
      std::weak_ptr<int> wp2(sp2);
      
      std::cout << "wp1 -> " << *wp1.lock() << " " << wp1.lock() << '\n';
      std::cout << "wp2 -> " << *wp2.lock() << " " << wp2.lock() << '\n';
    
      //这里的swap仅仅是交换wp2的各自的指向地址
      //并不会直接导致对应智能指针原始指针的地址交换
      //根据输出,所以很明显,交换完成之后weak_ptr对象指向发生了变化,但是并未导致share_ptr指针的指向变化
      wp1.swap(wp2);
    
      std::cout << "sp1 -> " << *sp1 << " " << sp1 << '\n';
      std::cout << "sp2 -> " << *sp2 << " " << sp2 << '\n';
      std::cout << "wp1 -> " << *wp1.lock() << " " << wp1.lock() << '\n';
      std::cout << "wp2 -> " << *wp2.lock() << " " << wp2.lock() << '\n';
    
      return 0;
    }
    
    输出如下:
    wp1 -> 10 0x11daf90
    wp2 -> 20 0x11dafd0
    sp1 -> 10 0x11daf90
    sp2 -> 20 0x11dafd0
    wp1 -> 20 0x11dafd0
    wp2 -> 10 0x11daf90
    
  • std::weak_ptr::reset成员,执行之后weak_ptr对象就像是重新执行了默认构造函数,又变成了一个空的对象
    // weak_ptr::reset example
    #include <iostream>
    #include <memory>
    
    int main () {
      std::shared_ptr<int> sp (new int(10));
    
      std::weak_ptr<int> wp(sp);
    
      std::cout << "1. wp " << (wp.expired()?"is":"is not") << " expired\n";
      std::cout << "4. wp " << wp.use_count() << " *wp " << *wp.lock() << '\n';
    
      wp.reset();
    
      std::cout << "2. wp " << (wp.expired()?"is":"is not") << " expired\n";
      std::cout << "3. sp " << sp.use_count() << " *sp " << *sp << '\n';
    
      return 0;
    }
    
    输出如下
    1. wp is not expired
    2. wp 2 *wp 10
    3. wp is expired
    4. sp 1 *sp 10
    

总结

shared_ptr和weak_ptr主要区别如下

  1. shared_ptr对象能够初始化实际指向一个地址内容而weak_ptr对象没办法直接初始化一个具体地址,它的对象需要由shared_ptr去初始化
  2. weak_ptr不会影响shared_ptr的引用计数,因为它是一个弱引用,只是一个临时引用指向shared_ptr。即使用shared_ptr对象初始化weak_ptr不会导致shared_ptr引用计数增加。依此特性可以解决shared_ptr的循环引用问题。
  3. weak_ptr没有解引用*和获取指针->运算符,它只能通过lock成员函数去获取对应的shared_ptr智能指针对象,从而获取对应的地址和内容。

参考文档:
http://www.cplusplus.com/reference/memory/weak_ptr/
https://www.boost.org/doc/libs/1_66_0/libs/smart_ptr/doc/html/smart_ptr.html#weak_ptr

  • 0
    点赞
  • 0
    评论
  • 14
    收藏
  • 一键三连
    一键三连
  • 扫一扫,分享海报

©️2021 CSDN 皮肤主题: 撸撸猫 设计师:马嘣嘣 返回首页
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

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

余额充值