天天看点
返回

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

文章目录

  • ​​weak_ptr描述​​
  • ​​声明​​
  • ​​作用​​
  • ​​原理实现​​
  • ​​函数成员使用​​
  • ​​总结​​

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

总结

  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智能指针对象，从而获取对应的地址和内容。
#include 初始化 引用计数
上一篇: code.php是什么,css code是什么
下一篇: HadoopHadoop笔记zkfc: zookeeper failover controller

继续阅读