C++11里shared_ptr源码剖析

很多人不知道引用计数放在哪，昨天为止我也不知道，O(∩_∩)O哈哈~

A *a = new A;
shared_ptr<A> sp(a);

上面代码发生了什么呢？

进入shared_ptr的构造函数

template<class _Ux>
explicit shared_ptr(_Ux *_Px){
_Resetp0(_Px, new _Ref_count<_Ux>(_Px));//这里是new出来的_Ref_count
}

1.shared_ptr继承_Ptr_base

2.Ptr_base里面有两个东西

private:
_Ty *_Ptr;
_Ref_count_base *_Rep;

一个是指向传进来的地址，一个是_Ref_count_base（用于保存引用计数，并且和week_ptr交流的一个类）基类是_Ref_count_base，引用计数就在基类里面

private:
_Atomic_counter_t _Uses;
_Atomic_counter_t _Weaks;

3.然后调用_Resetp0

template<class _Ux>
void _Resetp0(_Ux *_Px, _Ref_count_base *_Rx)
{
this->_Reset0(_Px, _Rx);
_Enable_shared(_Px, _Rx);
}

4.然后调用_Reset0

void _Reset0(_Ty *_Other_ptr, _Ref_count_base *_Other_rep)
{   //释放资源 and 利用新资源
if (_Rep != 0)
_Rep->_Decref();//如果原来有资源，释放原来的资源
_Rep = _Other_rep;
_Ptr = _Other_ptr;
}

5.把上面new的_Ref_count<_Ux>(_Px)赋值给_Ptr_base里面的_Ptr

把传进来的指针赋值给_Ptr

6.这样share_ptr里面就有一个_Ref_count了，这个_Ref_count在初始化的时候会把两个引用计数都赋值为1

_Ref_count_base()
{
_Init_atomic_counter(_Uses, 1);
_Init_atomic_counter(_Weaks, 1);
}

为啥weeks是1呢？不应该是0么？

因为在析构的时候weeks计数器是先减一再判断为不为0

// decrement weak reference count
if (_MT_DECR(_Mtx, _Weaks) == 0)
delete this;

很重要★★★★因为shared和weak都是共用一个_Ref_count_base

当所有的week_ptr都没了才释放自己，不然之后week访问这个类就会出错

有点晕？看幅图

下面是我精简后的源码，可以更好加深理解

template<class _Ty>
class _Ptr_base{
public:
_Ptr_base(): _Ptr(0), _Rep(0){}
long use_count()
{   // _Ref_count_base 存在就返回用户的引用个数 为NULL就返回0
return (_Rep ? _Rep->_Use_count() : 0);
}
void _Reset0(_Ty *_Other_ptr, _Ref_count_base *_Other_rep)
{   //释放资源 and 利用新资源
if (_Rep != 0)
_Rep->_Decref();//如果原来有资源，释放原来的资源
_Rep = _Other_rep;
_Ptr = _Other_ptr;
}
///////////////////赋值/////////////////////////
shared_ptr(const _Myt& _Other) _NOEXCEPT
{
_Reset(_Other._Ptr, _Other._Rep);
}
void _Reset(_Ty *_Other_ptr, _Ref_count_base *_Other_rep)
{   // release resource and take _Other_ptr through _Other_rep
if (_Other_rep)
_Other_rep->_Incref();//这里会把_Ref_count_base里面的_Uses + 1
_Reset0(_Other_ptr, _Other_rep);
}
//资源释放
void _Decref(){
if (_Rep != 0)
_Rep->_Decref();
}
private:
_Ty *_Ptr;
_Ref_count_base *_Rep;
};

template<class _Ty>
class shared_ptr: public _Ptr_base<_Ty>{
public:
template<class _Ux>
explicit shared_ptr(_Ux *_Px){
_Resetp0(_Px, new _Ref_count<_Ux>(_Px));//这里是new出来的_Ref_count
}
private:
template<class _Ux>
void _Resetp(_Ux *_Px)
{   // release, take ownership of _Px
_Resetp0(_Px, new _Ref_count<_Ux>(_Px));
}
template<class _Ux>
void _Resetp0(_Ux *_Px, _Ref_count_base *_Rx)
{
this->_Reset0(_Px, _Rx);
_Enable_shared(_Px, _Rx);
}
~shared_ptr() _NOEXCEPT
{   // release resource
this->_Decref();
}
};

class _Ref_count_base{
protected:
_Ref_count_base()
{   // construct
_Init_atomic_counter(_Uses, 1);
_Init_atomic_counter(_Weaks, 1);
}
void _Decref()
{   // uses - 1 等于0 就是放资源
if (_MT_DECR(_Mtx, _Uses) == 0)
{   // destroy managed resource, decrement weak reference count
delete _Ptr;//直接delete
// decrement weak reference count
if (_MT_DECR(_Mtx, _Weaks) == 0)//很重要★★★★因为shared和weak都是共用一个_Ref_count_base
delete this;//当所有的week_ptr都没了才释放自己，不然week访问这个类就会出错
}
}
private:
_Atomic_counter_t _Uses;
_Atomic_counter_t _Weaks;
};

template<class _Ty>
class _Ref_count: public _Ref_count_base
{   // handle reference counting for object without deleter
public:
_Ref_count(_Ty *_Px): _Ref_count_base(), _Ptr(_Px){}
private:
virtual void _Destroy()
{
delete _Ptr;
}
virtual void _Delete_this()
{   // destroy self
delete this;
}
_Ty * _Ptr;
};