shared_ptr学习总结

        shared_ptr是一种带有引用计数的智能指针，用于管理new动态分配的对象。本质上shared_ptr为一个类模板，模板参数就是shared_ptr要管理的对象的类型。shared_ptr重载了*和->操作符，使其对象很像指针，由于RAII机制，shared_ptr作为一个栈区对象在其作用域结束后会自动调用析构函数，析构函数里面完成delete原始指针的操作，不需要使用者手动delete，解除了使用new后而没有delete导致资源泄露的风险。

        相对于auto_ptr和scoped_ptr，shared_ptr带有引用计数，是一个最像指针的“智能指针”；下面列出boost库的shared_ptr的部分源码：

template<class T>
class shared_ptr
{
private:
    T* px;
    detail::shared_count pn;
public:
    shared_ptr() : px(0), pn(){}
    shared_ptr(Y * p);
    shared_ptr(shared_ptr &r) : px(r.px),pn(r.pn){}
    shared_ptr(Y * p, D d);		     //带有定制删除器的构造函数
  
    long use_count() const
    {
	return pn.use_count();
    }
    
    bool unique()	//判断唯一
    {
	return use_count() == 1;    //本质上如此
    }
    bool operator==(const shared_ptr & a, const shared_ptr & b)
    {
	return a.get() == b.get();
    } 
    T* get() const
    {
        return px;
    }

}

class shared_count
{
public:
	shared_count(shared_count& rc) : pi_(rc.pi_)
	{
		if (pi_ != 0) 
			pi_->add_ref_copy();		//拷贝构造
	}
	shared_count & operator=(shared_count const & r)
	{
		...
		pi_->add_ref_copy();		//赋值构造
	}

	long use_count() const
	{
	    return pi_ != 0 ? pi_->use_count() : 0;
	}

private:
	sp_counted_base* pi_;
};

class sp_counted_base
{
public:
	sp_counted_base(): use_count_(1),weak_ptr(1){}		//引用计数设置为1
	
	long use_count() const
	{
	    return use_count_;
	}
	
	void add_ref_copy()
	{
	    调用InterlockedIncrement  //windows提供的一种锁加操作		
	    //++use_count_ ，引用计数自增
	}

		
private:
      long use_count_;	//智能指针引用计数

 long weak_ptr;    //weak_ptr引用计数
}

        当创建一个shared_ptr对象sharedObj1来管理普通类对象Object时，引用计数设定为1，
此时使用sharedObj1拷贝构造一个sharedObj2时，调用sp_counted_base类的add_ref_acopy()
使引用计数加一

注：拷贝构造、赋值构造都是调用add_ref_acopy()。

        关于shared_ptr的循环引用，这里做简要总结：

循环引用的问题：
	使用shared_Ptr智能指针时可能存在的问题。
	问题：A智能指针类里面存放B，B智能指针类里面存放A，当构造对象a，b时分别用A，B管理时，a、b的引用计数
		  分别为2，退出A、B的作用域时，由于引用计数的关系，无法释放a，b，导致内存泄漏。
例：
class object
{
    int a;
    shared_ptr<int> p;
    ~object
    {
        cout << "~object" << endl;
    }
};

void test()
{
    shared_ptr<int> sp1(new int(1));
    shared_ptr<int> sp2(new int(2));
    cout << sp1.use_count() << endl;	//1
    cout << sp2.use_count() << endl;	//1
    sp1->p = sp2;
    sp2->p = sp1;
    cout << sp1.use_count() << endl;    //2
    cout << sp2.use_count() << endl;    //2
}

int main()
{
    test();	
    return 0;
}

分析上述代码：当删除sp1指向的节点的时候，则需要使其引用计数为1，则需释放sp1的p，即sp2，
而释放sp2又需先释放sp2的p，造成循环，sp1和sp2都无妨删除，导致内存泄露。
                        解决此问题就是将智能指针类object中的p设置成weak_ptr管理。引用计数始终为1。

weak_ptr是shared_ptr的辅助类，这里不做介绍。