1.智能指针解决的问题

int div()
{
     int a, b;
     cin >> a >> b;
     if (b == 0)
     throw invalid_argument("除0错误");
     return a / b;
}
void Func()
{
// 1、如果p1这里new 抛异常会导致p1不会Delete而导致内存泄漏
// 2、如果p2这里new 抛异常会导致p1和p2都不会delete而导致内存泄漏
// 3、如果div调用这里又会抛异常会导致p1和p2都不会delete而导致内存泄漏
     int* p1 = new int;
     int* p2 = new int;
     cout << div() << endl;
     delete p1;
     delete p2;
}
int main()
{
 try
 {
 Func();
 }
 catch (exception& e)
 {
     cout << e.what() << endl;
 }
 return 0;
}

综上，我们需要一种可以自动回收内存空间的指针。如果我们把指针套在一种类内，类在析构时会带着指针申请的空间一起析构掉。

class A
{
public:
	~A()
	{
		cout << "~A()" << endl;
	}
//private:
	int _a1 = 0;
	int _a2 = 0;
};

2.智能指针的使用及原理

2.1RAII

RAII（Resource Acquisition Is Initialization）直译：在初始化的时候获取资源。即在对象构造的时候获取资源，在对象的生命周期之中，控制对资源的访问，最后在对象析构的时候释放资源。

好处：

不用显示的释放资源（delete）。
对象所需的资源，在对象生命周期之内始终有效。

模拟实现1

template<class T>
class SmartPtr {
public:
	SmartPtr(T* ptr = nullptr)
		: _ptr(ptr)
	{}

	~SmartPtr()
	{
		if (_ptr)
		{
			cout << "Delete:" << _ptr << endl;
			delete _ptr;
		}
	}

private:
	T* _ptr;
};

2.2 原理

上述还不能将其称为智能指针，因为它还不具有指针的行为。指针可以解引用，也可以通过->去访问所指空间中的内容，因此：模板类中还得需要将* 、->重载下，才可让其像指针一样去使用。

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

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

智能指针的思想比较简单，但如何拷贝构造是个问题

这里程序崩溃了原因依然是之前的老问题，对同一块空间进行了两次析构。~~（别试，崩溃了）~~

那我们要跟之前一样实现深拷贝吗？不能，因为我们要的就是浅拷贝，要的就是用新的指针来指向我这块资源。

下面我们来看一下C++是如何对这里进行处理。

2.3 auto_ptr

auto_ptr<int>sp2(sp1)

C98里面的大槽点，对拷贝构造的处理沿用了右值引用的资源转移。（可右值本来就是将亡值，给了就给了。左值可不是啊，如果我还需要对sp1进行访问，那就会报访问空指针的错误）。我们将auto_ptr模拟实现一下

namespace chy
{
	template<class T>
	class auto_ptr
	{
	public:
		//用指针来构造的
		auto_ptr(T* ptr = nullptr)
			:_ptr(ptr)
		{}
		//C98中的auto_ptr对于拷贝的问题处理有问题，相当于右值的资源转移
		//会把ap里面的资源转移给构造出来的智能指针，而ap将不在管理这些资源（置空）
		//所以如果我们再次对与于ap进行解引用操作，将会出现访问空指针的问题
		auto_ptr(auto_ptr<T>& ap)
			:_ptr(ap._ptr)
		{
			ap._ptr = nullptr;
		}
		auto_ptr<T>& operator=(const auto_ptr<T>& ap)
		{
			if (this != &ap)//如果不是自己给自己赋值
			{
				if (_ptr)//原本的资源不管了（删除）
				{
					cout << "Delete" << _ptr << endl;
					delete _ptr;
				}
				_ptr = ap._ptr;
				ap._ptr = nullptr;
			}
			return *this;
		}
		~auto_ptr()
		{
			if (_ptr)
			{
				cout << "Delete:" << _ptr << endl;
				delete _ptr;
			}
		}
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;//  &(*_ptr)
		}
	private:
		T* _ptr;
	};

}

拷贝是没问题的但是不能对sp1再进行解引用操作了

3. C++11的智能指针

3.1 unique_ptr

~~遇到问题，逃避问题~~

不让拷贝

unique_ptr(const unique_ptr<T>& ap) = delete;
unique_ptr<T>& operator=(unique_ptr<T>& ap) = delete;

template<class T>
	class unique_ptr
	{
	public:
		unique_ptr(T* ptr=nullptr)
			:_ptr(ptr)
		{}
		unique_ptr(const unique_ptr<T>& ap) = delete;
		unique_ptr<T>& operator=(unique_ptr<T>& ap) = delete;

		~unique_ptr()
		{
			if (_ptr)
			{
				cout << "Delete:" << _ptr << endl;
				delete _ptr;
			}
		}
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
	private:
		T* _ptr;
	};

3.2 share_ptr

引用计数，每有一个指针指向我这块区域，引用计数++，当最后一个指向改位置的智能指针析构时，带着区域一起走。

我这个计数怎么设置？

{
    //..
private:
    static int count;
    //..
}
template<class T>
int shared_ptr<T>::_count = 0;

这样设计可以解决多个指针指向同一块空间的问题。可如果我有两块空间呢？这两块空间的引用计数是不是就变成了同一个了？

所以我们不能纳入静态成员变量，同时我们注意到，我们每指向一块空间，就需要一个单独的计数。那我们在指向空间的时候构造计数不就好了？

于是我们在构造函数中下笔

{   //...
	shared_ptr(T* ptr = nullptr)
		: _ptr(ptr)			
        , _pCount(new int(1))
	{}
private:
    T* _ptr;
    int _pCount;
}

整体实现

template<class T>
	class shared_ptr
	{
	public:
		shared_ptr(T* ptr)
			:_ptr(ptr)
			,_pCount(new int(1))
		{}
		shared_ptr(const shared_ptr<T>& sp)
			:_ptr(sp._ptr)
			, _pCount(sp._pCount)
		{
			//二者公用一个计数
			(*_pCount)++;
		}
		shared_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			//赋值是 两个已有对象进行赋值 要先对_ptr指向的地方的计数--
			if (_ptr == sp._ptr)//两个指向的是同一块 区域 不用赋值
			{
				return *this;
			}
			if (--(*_pCount) == 0)
			{
				delete _ptr;
				delete _pCount;
			}
			_ptr = sp._ptr;
			_pCount = sp._pCount;
			++(*_pCount);
			return *this;
		}
		~shared_ptr()
		{
			if (--(*_pCount) == 0)
			{
				cout << "Delete:" << _ptr << endl;
				delete _ptr;
				delete _pCount;
			}
		}
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}
	private:
		T* _ptr;
		int* _pCount;
	};