weak_ptr源码分析

之前分析了shared_ptr的框架，这次来说一下shared_ptr的兄弟weak_ptr，它们常常是一起出现的。

weak_ptr顾名思义就是弱指针，它不会增加对象的引用计数，欸有重载operator*和operator->，使用时，应当通过weak_ptr的lock函数构造一个shared_ptr。

作用：防止循环引用（以后博客分析）。应用：在enable_shared_from_this类中，它有一个weak_ptr weak_this_成员。当对象构造完成后，在类成员函数内部可以调用shared_from_this获得该对象自身类型的shared_ptr。千万不要在构造函数里调用share_from_this，因为this还没有完全构造出来，此时无法根据this构造一个正确的weak_ptr。

 

weak_ptr源码

template<class T> class weak_ptr
{
private:

// Borland 5.5.1 specific workarounds
typedef weak_ptr<T> this_type;

public:

typedef typename boost::detail::sp_element< T >::type element_type;

//pn是weak_count，而不是shared_count，所以weak_ptr不会引起指针引用计数增加。
weak_ptr() BOOST_NOEXCEPT : px(0), pn() // never throws in 1.30+
{
}

//  generated copy constructor, assignment, destructor are fine...

//如果    定义"BOOST没有右值引用"   为假
#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )

// ... except in C++0x, move disables the implicit copy
//支持copy assignment
weak_ptr( weak_ptr const & r ) BOOST_NOEXCEPT : px( r.px ), pn( r.pn )
{
}

weak_ptr & operator=( weak_ptr const & r ) BOOST_NOEXCEPT
{
px = r.px;
pn = r.pn;
return *this;
}

#endif

//
//  The "obvious(明显的)" converting constructor implementation:
//
//  template<class Y>
//  weak_ptr(weak_ptr<Y> const & r): px(r.px), pn(r.pn) // never throws
//  {
//  }
//
//  has a serious problem.
//
//  r.px may already have been invalidated(使无效). The px(r.px)
//  conversion may require(需要) access to *r.px (virtual inheritance).
//
//  It is not possible to avoid spurious(假的，伪造的) access violations since
//  in multithreaded programs r.px may be invalidated at any point.
//

template<class Y>
#if !defined( BOOST_SP_NO_SP_CONVERTIBLE )

weak_ptr( weak_ptr<Y> const & r, typename boost::detail::sp_enable_if_convertible<Y,T>::type = boost::detail::sp_empty() )

#else

weak_ptr( weak_ptr<Y> const & r )

#endif
BOOST_NOEXCEPT : px(r.lock().get()), pn(r.pn)
{
boost::detail::sp_assert_convertible< Y, T >();
}

template<class Y>
weak_ptr( weak_ptr<Y> && r ) BOOST_NOEXCEPT : px( r.lock().get() ), pn( static_cast< boost::detail::weak_count && >( r.pn ) )  //强转为右值
{
boost::detail::sp_assert_convertible< Y, T >();
r.px = 0;
}

// for better efficiency in the T == Y case
weak_ptr( weak_ptr && r )
BOOST_NOEXCEPT : px( r.px ), pn( static_cast< boost::detail::weak_count && >( r.pn ) )
{
r.px = 0;
}

// for better efficiency in the T == Y case
weak_ptr & operator=( weak_ptr && r ) BOOST_NOEXCEPT
{
this_type( static_cast< weak_ptr && >( r ) ).swap( *this );
return *this;
}

template<class Y>
weak_ptr( shared_ptr<Y> const & r )
BOOST_NOEXCEPT : px( r.px ), pn( r.pn ) //重点weak_ptr的pn=shared_ptr的pn，也就是说weak_count=shared_count
{
boost::detail::sp_assert_convertible< Y, T >();
}

#if !defined(BOOST_MSVC) || (BOOST_MSVC >= 1300)

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;
}

#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )

template<class Y>
weak_ptr & operator=( weak_ptr<Y> && r ) BOOST_NOEXCEPT
{
this_type( static_cast< weak_ptr<Y> && >( r ) ).swap( *this );
return *this;
}

#endif

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;
}

#endif

//将weak_ptr提升为shared_ptr，如果已经过期，则返回一个空shared_ptr
shared_ptr<T> lock() const BOOST_NOEXCEPT
{
return shared_ptr<T>( *this, boost::detail::sp_nothrow_tag() );   //调用shared_ptr(const weak_ptr<T>& r, sp_nothrow_tag());
}

//返回shared_ptr的引用计数，pn是weak_count类型，但是它实际上转调它持有的sp_counted_base指针（和shared_ptr持有同一个)的use_count()函数，所以可以返回所有shared_ptr引用计数的相关信息，下同。
long use_count() const BOOST_NOEXCEPT
{
return pn.use_count();
}

//判断shared_ptr是否过期，也就是引用计数是否为0，如果为0，说明shared_ptr已经过期死了，返回true
bool expired() const BOOST_NOEXCEPT
{
return pn.use_count() == 0;
}

bool _empty() const // extension, not in std::weak_ptr
{
return pn.empty();
}

void reset() BOOST_NOEXCEPT // never throws in 1.30+
{
this_type().swap(*this);
}

void swap(this_type & other) BOOST_NOEXCEPT
{
std::swap(px, other.px);
pn.swap(other.pn);
}

template<typename Y>
void _internal_aliasing_assign(weak_ptr<Y> const & r, element_type * px2)
{
px = px2;
pn = r.pn;
}

template<class Y> bool owner_before( weak_ptr<Y> const & rhs ) const BOOST_NOEXCEPT
{
return pn < rhs.pn;
}

template<class Y> bool owner_before( shared_ptr<Y> const & rhs ) const BOOST_NOEXCEPT
{
return pn < rhs.pn;
}

下面是weak_count的源码：

class weak_count
{
private:

sp_counted_base * pi_;

friend class shared_count;

public:

weak_count(): pi_(0) // nothrow
{
}

weak_count(shared_count const & r): pi_(r.pi_) // nothrow
{
if(pi_ != 0) pi_->weak_add_ref();
}

weak_count(weak_count const & r): pi_(r.pi_) // nothrow
{
if(pi_ != 0) pi_->weak_add_ref();
}

// Move support

#if !defined( BOOST_NO_CXX11_RVALUE_REFERENCES )
weak_count(weak_count && r): pi_(r.pi_) // nothrow
{
r.pi_ = 0;
}
#endif

~weak_count() // nothrow
{
if(pi_ != 0) pi_->weak_release();    //weak_count析构一次，就减少一次sp_count_base的计数!!!!!!
}

weak_count & operator= (shared_count const & r) // nothrow
{
sp_counted_base * tmp = r.pi_;

if( tmp != pi_ )
{
if(tmp != 0) tmp->weak_add_ref();
if(pi_ != 0) pi_->weak_release();
pi_ = tmp;
}

return *this;
}

weak_count & operator= (weak_count const & r) // nothrow
{
sp_counted_base * tmp = r.pi_;

if( tmp != pi_ )
{
if(tmp != 0) tmp->weak_add_ref();
if(pi_ != 0) pi_->weak_release();
pi_ = tmp;
}

return *this;
}

void swap(weak_count & r) // nothrow
{
sp_counted_base * tmp = r.pi_;
r.pi_ = pi_;
pi_ = tmp;
}

long use_count() const // nothrow
{
return pi_ != 0? pi_->use_count(): 0;
}

bool empty() const // nothrow
{
return pi_ == 0;
}

friend inline bool operator==(weak_count const & a, weak_count const & b)
{
return a.pi_ == b.pi_;
}

friend inline bool operator<(weak_count const & a, weak_count const & b)
{
return std::less<sp_counted_base *>()(a.pi_, b.pi_);
}
};

//在这里初始化shared_count中的那两个函数，即利用wakt_count的sp_count_base初始化share_count的sp_count_base，它们是共享的
//这是在调用weak_ptr的lock函数用weak_ptr构造shared_ptr，然后调用本函数的
inline shared_count::shared_count( weak_count const & r ): pi_( r.pi_ )
{
if( pi_ == 0 || !pi_->add_ref_lock() )
{
boost::throw_exception( boost::bad_weak_ptr() );
}
}

inline shared_count::shared_count( weak_count const & r, sp_nothrow_tag ): pi_( r.pi_ )
{
if( pi_ != 0 && !pi_->add_ref_lock() )
{
pi_ = 0;
}
}

值得注意的是，weak_ptr自身也是引用计数型智能指针，也有引用计数。weak_ptr也支持拷贝分配之类的函数。

上面代码最后的这两个函数是shared_count类的构造函数之一，这是使用weak_ptr的lock函数底层要调用的之一。lock函数是使用weak_ptr构造shared_ptr，这回调用shared_ptr的weak_ptr构造方法，然后shared_ptr的成员shread_count自然也要调用以weak_ptr为参数的构造方法。并且由于lock提升这个操作有多线程并发的可能，所以这里调用的不是sp_counted_base函数的add_ref_copy（该函数是原子的，但功能简单，不能说明提升成功或失败），而是add_ref_lock函数，gcc版本是这样实现的：

inline int atomic_conditional_increment( int * pw )
{
spinlock_pool<1>::scoped_lock lock( pw );

int rv = *pw;
if( rv != 0 ) ++*pw;
return rv;
}

首先对pw的内存进行上锁，然后再进行相应操作。如果*pw不为0，则weak_ptr提升成功，增加引用计数。如果为0，说明shared_ptr对象已死，不能提升，不增加引用计数，返回0。在shared_count构造函数中（就是上面那个），取消pi_的赋值（不打算指向weak_ptr的sp_counted_base），将它重新赋为空。

如此一来，便可实现weak_ptr提升称为shared_ptr的线程安全了。