C++ 智能指针——主要包括：《为什么需要智能指针》《RALL的使用原理》《auto，unique，share三者联系和区别，以及三者的实现》《RALL扩展训练》

《一》为什么需要智能指针？
在我们上一节课 异常 哪一节课的时候，我们知道了之前我们提到的问题，为下面的两个问题，我们还没有解决。

1. malloc出来的空间，没有进行释放，存在内存泄漏的问题。
2. 异常安全问题。如果在malloc和free之间如果存在抛异常，那么还是有内存泄漏。这种问题就叫异常安全。
   《二》智能指针的使用及原理

（2.1）RAII

RAII（Resource Acquisition Is Initialization）是一种利用对象生命周期来控制程序资源（如内存、文件句柄、网络连接、互斥量等等）的简单技术。

在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。借此，我们实际上把管理一份资源的责任托管给了一个对象。这种做法有两大好处：

1. 不需要显式地释放资源。
2. 采用这种方式，对象所需的资源在其生命期内始终保持有效。

下面，我们就实现一下，下面的一段代码来进行分析。

template<class T>
class SmartPtr {
public:
	SmartPtr(T* ptr)
		: _ptr(ptr)
	{}
	~SmartPtr()
	{
		cout << _ptr << endl;
		delete[] _ptr;
	}
private:
	T* _ptr;
};

void func()
{
vector<int> v;  //这里还没有使用智能指针，会出现内存没有释放，
	v.at(0) = 10;

	int* p = new int;
	SmartPtr<int> sp1(p);


	/*vector<int> v(10);
	size_t pos;
	cin >> pos;
	v.at(pos) = 10;

	int* p = new int;
	SmartPtr<int> sp1(p);*/
}
int main()
{
	try{
		func();

	}
	catch (exception& e)
	{
		cout << e.what() << endl;
	}
	return 0;
}

当我们使用没有被屏蔽的代码的时候，我们可以发现它的内存是不没有释放的，下面我们看一下执行的程序。

当我们打开第二段代码的时候，可以发现，无论在什么样的情况下面，内存总是被释放的。

（2）下面我们就解决一下这个问题，看一下，下面的代码：

//c++98 auto_ptr  管理权转移，设计缺陷，严谨使用，
void test_auto_ptr()//一般不采取这个，问题不能被好的解决。
{
	auto_ptr<int> ap(new int);
	*ap = 10;
	cout << *ap << endl;

	auto_ptr<int> copy(ap);
	cout << *ap << endl;
	cout << *copy << endl;
}

//c++11 防止拷贝，简单粗暴的设计，鼓励使用
void test_unique_ptr()
{
	unique_ptr<int> up(new int);
	*up = 10;
	cout << *up << endl;

	//unique_ptr<int> copy(up);
	//cout << *ap << endl;
	//cout << *copy << endl;
}

//c++11 引用计数，支持拷贝，鼓励使用
void test_shared_ptr()
{
	shared_ptr<int> sp(new int);
	*sp = 10;
	cout << *sp << endl;

	shared_ptr<int> copy(sp);
	cout << *sp << endl;
	cout << *copy << endl;
}

int main()
{
	//test_auto_ptr();
	//test_unique_ptr();
	test_shared_ptr();

	return 0;
}

在这里面，我们分别使用了auto，unique，share 这三种智能指针，但是，这三种的能里是截然不同的，在我们使用auto的时候，它的管理直接就被转移了，而且存在很大的缺陷，不建议被使用，在下面使用的unique的时候,她很好的解决了这个问题，但是它不能被拷贝，它是防止拷贝的，我们提议可以使用，最后面的share，这个放到最后面，当然，它是很强的，不仅能很好的使用，而且可以可以被拷贝。对照，上面的代码，我们执行了一下程序，我们看一下结果;

这张图片很好说明了，unique和share的区别和联系了，

《二》我们就是实现一下，三者的联系关系，以及函数调用

namespace DPF
{
	template<class T>
	class AutoPtr
	{
	public:
		AutoPtr(T* ptr)
			:_ptr(ptr)
		{}
	~AutoPtr()
	{
		if (_ptr)
		{
			cout << "delete:" << _ptr << endl;
			delete _ptr;
		}
	}


	// BIT::AutoPtr<int> copy(ap);
	AutoPtr(AutoPtr<T>& ap)
	{
		_ptr = ap._ptr;
		ap._ptr = nullptr;
	}

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

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

template<class T>
class UniquePtr
{
public:
	UniquePtr(T* ptr)
		:_ptr(ptr)
	{}

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

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

	T* operator->()


	{
			return _ptr;
		}

		// C++11 防拷贝
		//UniquePtr(UniquePtr<T>& ap) = delete;
	private:
		// 防拷贝 C++98 1.只声明不实现 2.私有
		UniquePtr(UniquePtr<T>& ap);
	private:
		T* _ptr;
	};

	template<class T>
	class SharedPtr    //引用计数
	{
	public:
		SharedPtr(T* ptr)
			:_ptr(ptr)
			, _pcount(new int(1))
			, _pmtx(new mutex)
		{}

		~SharedPtr()
		{
			/*if (--(*_pcount) == 0)
			{
			cout << "delete:" << _ptr << endl;
			delete _ptr;
			delete _pcount;
			}*/

			Realase();
		}

		SharedPtr(const SharedPtr<T>& sp)
			:_ptr(sp._ptr)
			, _pcount(sp._pcount)
			, _pmtx(sp._pmtx)
		{
			//++(*_pcount);
			AddRefCount();
		}

		// sp1 = sp2
		SharedPtr<T>& operator=(const SharedPtr<T>& sp)
		{
			//if (this != &sp)  //遇到自己给自己赋值的情况
			if (_ptr != sp._ptr)
			{
				/*if (--(*_pcount) == 0)
				{
				delete _ptr;
				delete _pcount;
				}*/

				Realase();

				_ptr = sp._ptr;
				_pcount = sp._pcount;
				//++(*_pcount);
				AddRefCount();//代替上面注销部分，以上代码也是这样。
			}

			return *this;
		}

		void AddRefCount()
		{
			_pmtx->lock();
			++(*_pcount);
			_pmtx->unlock();
		}

		void Realase()
		{
			bool deleteflag = false;
			_pmtx->lock();
			if (--(*_pcount) == 0)
			{
				cout << "delete" << _ptr << endl;
				delete _pcount;
				delete _ptr;
				deleteflag = true;
			}
			_pmtx->unlock();

			if (deleteflag == true)
				delete _pmtx;
		}

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

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

		int use_count()
		{
			return *_pcount;
		}

	private:
		T* _ptr;
		int* _pcount;
		mutex* _pmtx;
	};
}

void TestAutoPtr()
{
	DPF::AutoPtr<int> ap(new int);
	DPF::AutoPtr<int> copy(ap);
}

void TestUniquePtr()
{
	DPF::UniquePtr<int> ap(new int);
	//DPF::UniquePtr<int> copy(ap);//防止拷贝的
}

void TestSharedPtr()
{
	DPF::SharedPtr<int> sp(new int);
	DPF::SharedPtr<int> copy(sp);

	DPF::SharedPtr<int> sp1(new int);
	DPF::SharedPtr<int> sp2(sp1);

	sp = sp1;
	copy = sp1;

	//sp1 = sp1;
	//sp1 = sp2;
}

int main()
{
	//TestAutoPtr();
	//TestUniquePtr();
	TestSharedPtr();

	return 0;
}

通过这三者的分析以及代码的实现，调用，这三种不同的函数，有着不一样的功能，下面，同学们，可以看着代码的实现，来使用这三种接口，《这几种，我都已经测试过了，没有什么异常了，可以直接使用了》

《三》RALL扩展训练

#include<iostream>
#include <memory>
#include <thread>
#include <mutex>

using namespace std;


template<class lock>
class UnipueLock
{
public:
	UnipueLock(lock& lock)
	:_lock(lock)
	{
		_lock.lock();
	}
	~UnipueLock()
	{
		_lock.unlock();
	}
private:
	lock& _lock;//成员变量给的是引用。
};

int main()
{
	mutex mtx;
	UnipueLock<mutex> lock(mtx);

	return 0;
}

上面的代码，就是根据加锁，解锁的智能指针方案，来实现异常安全导致的死锁问题。