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，不需要虚函数的开销，确实性能强一些。