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的线程安全了。