详细理解C++11中的智能指针

1. shared_ptr在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共

享。

2. 在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减

一。

3. 如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源；

4. 如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对

象就成野指针了。

std::shared_ptr<int> p1(new int(10)); // 引用计数=1  
std::shared_ptr<int> p2 = p1;         // 引用计数=2  
p1.reset();                           // 引用计数=1  
// p2析构时引用计数归0，资源释放  

我们下面来看一个列子，看看会出现什么问题

首先构造一个结构体

struct B
{
	A _val;

	shared_ptr<B> _next ;
	shared_ptr<B> _prev;

};

运行一下下面这份代码，观察一下允许结果

	shared_ptr<B> sp1(new B);
	shared_ptr<B> sp2(new B);
	sp1->_next = sp2;
	sp2->_prev = sp1;

我们发现只调用了构造函数，好像没有析构，这就是我们要说的一个问题叫做，循环引用

为什么会出现这种情况呢？下面我们来分析一下

那我们怎么解决这个问题呢？

C++11中又提供了一个weak_ptr,专门用来解决shared_ptr中的循环引用问题。weak_ptr时专门用来存放资源的，他不会管理资源。所以不会有引用计数的增加。我们将结构体B中的成员修改一下

struct B
{
	A _val;

	weak_ptr<B> _next ;
	weak_ptr<B> _prev;

};

这样就可以正常的析构了

定制删除器

我们接下来看一下下面的列子，构造一个数组，那么我们所写的析构函数就会存在问题，这就需要我们在创建数组的时候，定制一个删除器给shared_ptr运用

shared_ptr<A> sp1(new A[10]);

这本质上就是一个可调用函数，我们可以传仿函数，或者lambda表达式都是可以，我们用仿函数来实现

template<class T>
struct DeleteArr
{
	void operator()(T* ptr)
	{
		delete[] ptr;
	}

};

此时我们只需要在构造的时候，加入我们的定制删除器就可以解决了

	shared_ptr<A> sp1(new A[10],DeleteArr<A>());

接下来我们来简单模拟实现shared_ptr，和weak_ptr.

shard_ptr:

	template<class T>
class shared_ptr
{
public:
	shared_ptr(T* ptr = nullptr)
		:_ptr(ptr)
		, _pcount(new int(1))
	{
	};

	template<class T,class D>//如果传入的是数组，则需要定制删除器，用模板重载一个构造函数
	shared_ptr(T* ptr,D del)
		:_ptr(ptr)
		, _pcount(new int(1))
		,_del(del)
	{
	};


	shared_ptr(const shared_ptr<T>& sp)
		:_ptr(sp._ptr)
		, _pcount(sp._pcount)
	{
		(*_pcount)++;
	}

	T& operator*()
	{
		return *_ptr;
	}

	T* operator->()
	{
		return _ptr;
	}


	shared_ptr<T>& operator=(shared_ptr<T>& sp)
	{
        //防止自我拷贝
		if (_ptr == sp._ptr)
			return *this;
        
           
		if (--(*_pcount) == 0)
		{

			cout << "delete: " << _ptr << endl;;
			delete _ptr;
			delete _pcount;
		}

		_ptr = sp._ptr;
		_pcount = sp._pcount;

		++(*_pcount);

		return *this;
	}

	T* get() const//为了方便weak_ptr获取资源
	{
		return _ptr;
	}

	~shared_ptr()
	{
		if (--(*_pcount) == 0)
		{
			cout << "delete: " << _ptr;

			delete _pcount;
			//_del(_ptr);
			delete _ptr;
		}

	}

private:
	T* _ptr;
	int* _pcount;
    
    //因为我们传入的类型可能是仿函数，也可能是lambda表达式，
     //所以用一个包装器来作为删除器，并给一个默认删除值
	function<void(T*)> _del = [](T* ptr){ delete ptr;};
};

weak_ptr:

	template<class T>
	class weak_ptr
	{
	public:
		weak_ptr()
			:_ptr(nullptr)
		{
		};

		weak_ptr(const  xc::shared_ptr<T>& sp)
			:_ptr(sp.get())
		{

		};

		weak_ptr<T>& operator=(const xc::shared_ptr<T>& sp)
		{
			_ptr = sp.get();

			return *this;
		}

	private:
		T* _ptr;
	};