intrusive_ptr源码分析

intrusive_ptr是一个侵入式的引用计数型智能指针，它可以用于以下两种情形：

• 对内存占用要求非常严格，要求必须与原始指针一样
• 现存代码已经有了引用计数机制管理的对象

boost库不推荐使用intrusive_ptr，因为shared_ptr已经非常强大且灵活，工作足够好，可以满足绝大部分的需要。

下面来看一下intrusive的源码：

template<class T> class intrusive_ptr{private:    typedef intrusive_ptr this_type;public:    typedef T element_type;    intrusive_ptr() BOOST_NOEXCEPT : px( 0 )    {    }    intrusive_ptr( T * p, bool add_ref = true ): px( p )    {        if( px != 0 && add_ref ) intrusive_ptr_add_ref( px );    }    intrusive_ptr(intrusive_ptr const & rhs): px( rhs.px )    {        if( px != 0 ) intrusive_ptr_add_ref( px );    }    ~intrusive_ptr()    {        if( px != 0 ) intrusive_ptr_release( px );    }    // Move support    //支持C++11移动构造，此处省略    intrusive_ptr & operator=(intrusive_ptr const & rhs)    {        this_type(rhs).swap(*this);        return *this;    }    intrusive_ptr & operator=(T * rhs)    {        this_type(rhs).swap(*this);        return *this;    }    void reset() BOOST_NOEXCEPT    {        this_type().swap( *this );    }    void reset( T * rhs )    {        this_type( rhs ).swap( *this );    }    T * get() const BOOST_NOEXCEPT    {        return px;    }    T & operator*() const    {        BOOST_ASSERT( px != 0 );        return *px;    }    T * operator->() const    {        BOOST_ASSERT( px != 0 );        return px;    }// implicit conversion to "bool"#include <boost/smart_ptr/detail/operator_bool.hpp>    void swap(intrusive_ptr & rhs) BOOST_NOEXCEPT    {        T * tmp = px;        px = rhs.px;        rhs.px = tmp;    }private:    T * px;};

呵呵，非常简单，就是这么一点。但是我们发现，intrusive_ptr的构造析构等函数中，都使用了所管理的指针，以其作为参数执行某个函数。但实际上，这些函数是没有定义的。需要我们自己定义。

因为这几个函数的源码是这样的：

template< typename DerivedT, typename CounterPolicyT >void intrusive_ptr_add_ref(const intrusive_ref_counter< DerivedT, CounterPolicyT >* p) BOOST_NOEXCEPT;template< typename DerivedT, typename CounterPolicyT >void intrusive_ptr_release(const intrusive_ref_counter< DerivedT, CounterPolicyT >* p) BOOST_NOEXCEPT;

呵，只有声明。

所以我们在使用intrusive_ptr是要自己提供引用计数，这就叫侵入式。我们可以在要管理的对象内部使用友元函数来实现上面那两个函数，执行计数器的加或减。但是通常我们会采用继承的方式实现，实现一个引用计数器基类，提供intrusive_ptr_add_ref()和intrusive_ptr_release()两个函数，然后继承它即可。

示例代码如下：

#include <iostream>#include <boost/intrusive_ptr.hpp>class reference_counter {  int ref_count_;public:    reference_counter() : ref_count_(0) {}    virtual ~reference_counter() {}    friend void intrusive_ptr_add_ref(reference_counter *p) {       ++p->ref_count_;    }       friend void intrusive_ptr_release(reference_counter *p) {      if(--p->ref_count_)        delete p;    }       /*  error    int use_count() {        return ref_count_;    }    */protected:    reference_counter& operator=(const reference_counter&) {    // 无操作      return *this;    }   private:    // 禁止复制构造函数reference_counter(const reference_counter&); };class some_class : public reference_counter {public:  some_class() {    std::cout << "some_class::some_class()\n";  }  some_class(const some_class& other) {    std::cout << "some_class(const some_class& other)\n";  }  ~some_class() {    std::cout << "some_class::~some_class()\n";  }};int main(){  std::cout << "Before start of scope\n";  {    boost::intrusive_ptr<some_class> p1(new some_class());    boost::intrusive_ptr<some_class> p2(p1);    //std::cout<<p2.use_count()<<std::endl;  }  std::cout << "After end of scope \n";}

输出：

由于intrusive_ptr源码（上面已经给了）中不提供use_count()这个成员函数，所以我们也无法获得use_count值。

也许这样用你会觉得麻烦，不过实际上，boost中已经为我们实现了一个引用计数器的基类，我们使用intrusive_ptr时，继承该类就无需自己再费神了。

boost库中的引用计数基类是这样的：

template< typename DerivedT, typename CounterPolicyT >class intrusive_ref_counter{private:    //! Reference counter type    typedef typename CounterPolicyT::type counter_type;    //! Reference counter    mutable counter_type m_ref_counter;public:    /*!     * Default constructor     *     * \post <tt>use_count() == 0</tt>     */    intrusive_ref_counter() BOOST_NOEXCEPT : m_ref_counter(0)    {    }    /*!     * Copy constructor     *     * \post <tt>use_count() == 0</tt>     */    intrusive_ref_counter(intrusive_ref_counter const&) BOOST_NOEXCEPT : m_ref_counter(0)    {    }    /*!     * Assignment     *     * \post The reference counter is not modified after assignment     */    intrusive_ref_counter& operator= (intrusive_ref_counter const&) BOOST_NOEXCEPT { return *this; }    /*!     * \return The reference counter     */    unsigned int use_count() const BOOST_NOEXCEPT    {        return CounterPolicyT::load(m_ref_counter);    }protected:    /*!     * Destructor     */    BOOST_DEFAULTED_FUNCTION(~intrusive_ref_counter(), {})    friend void intrusive_ptr_add_ref< DerivedT, CounterPolicyT >(const intrusive_ref_counter< DerivedT, CounterPolicyT >* p) BOOST_NOEXCEPT;    friend void intrusive_ptr_release< DerivedT, CounterPolicyT >(const intrusive_ref_counter< DerivedT, CounterPolicyT >* p) BOOST_NOEXCEPT;};

唉，上面这些就是intrusive_ptr的用法，有点蛋疼。不过却是让人感觉很叼的样子。侵入式的智能指针，相比shared_ptr，不需要虚函数的开销，确实性能强一些。