boost中的shared_ptr

看了一下boost中的shared_ptr的源码，简化出了如下的版本，帮助理解shared_ptr的工作原理

class sp_counted_base{
public:
long use_count;

public:
sp_counted_base():use_count(1){}
void add_ref_copy(){
    ++use_count;//此处是原子操作，这里简化了
}
virtual void dispose()=0;
void release(){
    if((--use_count)==0)//此处也是原子操作，这里简化了
    {
        dispose();
        delete this;  
    }
}
};

template <class X>
class sp_counted_impl_p : public sp_counted_base{
private:
  X *px_;
public:
sp_counted_impl_p(X *px):px_(px){}
virtual void dispose(){
  delete px_;
}
};

class shared_count{
public:
sp_counted_base *pi;
public:
shared_count():pi(0){}
shared_count(shared_count const &r):pi(r.pi){
    pi->add_ref_copy();
}

template <class Y>
shared_count(Y *y):pi(0){
try{
    pi=new sp_counted_impl_p<Y>(y);
}catch(...){
    delete y;
}
}
void swap(shared_count &r){
sp_counted_base *tmp=r.pi;
r.pi=pi;
pi=tmp;
}
~shared_count(){
if(pi!=0)
    pi->release();
}
};

template <class T>
class shared_ptr{
public:
T *px;
shared_count pn;

public:
shared_ptr():px(0),pn(){}

template <class Y>
shared_ptr(Y *p):px(p),pn(){
shared_count(p).swap(pn);
}
shared_ptr(shared_ptr const &r):px(r.px),pn(r.pn){}
};

class testClass{
public:
~testClass(){
std::cout<<"testClass 被析构了"<<std::endl;
}
};

void test(){
shared_ptr<testClass> sp1(new testClass);
std::cout<<(sp1.pn.pi->use_count)<<std::endl;
shared_ptr<testClass> sp2(sp1);
std::cout<<(sp1.pn.pi->use_count)<<" "<<(sp2.pn.pi->use_count)<<std::endl;
}

最终的输出结果是

1
2 2
testClass被析构了

从上面的代码可以看出，shared_ptr虽然持有对象的指针，但是并不负责delete，delete的发生是在shared_ptr被销毁时它内部的shared_count pn负责的，
pn的析构函数判断pi是否为空指针，如果不是，就调用pi的release函数，sp_counted_base先将计数器减一，如果是0，就调用dispose函数，dispoase的实现是在sp_counted_impl_p 中实现的，最终由dispose函数负责delete。同时，release函数将delete自身，因为pi=new sp_counted_impl_p(y);为了避免内存泄露，也要删除。