智能指针- 原来如此

为什么需要智能指针

• 1. 当程序员手动malloc或new出来的空间没有手动释放。
• 2. 存在异常安全问题。如果new和delete之间如果存在抛异常，那么还是有内存泄漏。这种问题就叫异常安全。

内存泄漏

什么是内存泄漏以及内存泄漏的危害

• 什么是内存泄漏: 内存泄漏是指，在内存不使用的情况下，由于疏忽或错误造成程序未能释放。内存泄漏并不是指内存在物理上的消失，而是应用程序分配某段内存后，因为设计错误，失去了对该段内存的控制，因而造成了内存的浪费。

• 内存泄漏的危害：长期运行的程序出现内存泄漏影响很大，如操作系统，后台服务器等，出现内存泄漏会导致相应越来越慢，最终卡死。

内存泄漏分类

一般情况下我们关心两方面的内存泄漏：

• 堆内存泄露（Heap Leak）
  堆内存指的是程序执行中依据须要分配通过malloc / calloc / realloc / new等从堆中分配的一块内存，用完后必须通过调用相应的 free或者delete 删掉。假设程序的设计错误导致这部分内存没有被释放，那么以后这部分空间将无法再被使用，就会产生Heap Leak。

• ** 系统资源泄漏**
  指程序使用系统分配的资源，比方套接字、文件描述符、管道等没有使用对应的函数释放掉，导致系统资源的浪费，严重可导致系统效能减少，系统执行不稳定。

因此提出智能指针用来预防内存泄漏！！

智能指针的使用及原理

1. 利用RAII的思想。
2. 保证它像指针一样去使用（重载operator*和operator->）
3. 解决智能指针拷贝问题

RAII

资源获取及初始化，利用对象的生命周期来控制程序资源的技术。
在对象构造时获取资源，接着控制对资源的访问使之在对象的生命周期内始终保持有效，最后在对象析构的时候释放资源。
RAII详情点击

几种智能指针

auto_ptr

C++98版本库中提供了auto_ptr的智能指针。
auto_ptr的实现原理：管理权转移的思想。

namespace guokk
{
	template<class T>
	class auto_ptr{
	public:
		auto_ptr(T* ptr = nullptr)
			:_ptr(ptr)
		{}
		//一旦发生拷贝，就将ap中资源转移到当前对象中，然后另ap与其所管理资源断开联系，
		auto_ptr(auto_ptr<T>& ap)
			:_ptr(ap._ptr)
		{
			ap._ptr = nullptr;
		}

		auto_ptr<T>& operator=(auto_ptr<T>& ap)
		{
			if (_ptr != ap._ptr)
			{
				if (_ptr != nullptr)
					delete _ptr;

				_ptr = ap._ptr;

				ap._ptr = nullptr;
			}
			return *this;
		}
		T& operator*()
		{
			return *_ptr;
		}
		T* operator->()
		{
			return _ptr;
		}

		~auto_ptr()
		{
			if (_ptr)
				delete _ptr;
		}
	private:
		T* _ptr;
	};
}

当然auto_ptr的问题也是非常大的：他并没有解决对象的拷贝与赋值，当对象拷贝或赋值后，前面的对象就悬空了，再次使用就会出问题。

unique_ptr

C++11中开始提供更靠谱的unique_ptr
unique_ptr设计原理：它非常粗暴，防拷贝。

namespace guokk{
// 防止其拷贝构造
	template<class T>
	class unique_ptr{
	public:
		unique_ptr(T*ptr = nullptr)
			:_ptr(ptr)
		{}
		~unique_ptr()
		{
			if (_ptr)
			{
				delete _ptr;
				_ptr = nullptr;
			}
		}

		T* operator->()
		{
			return _ptr;
		}
		T& operator*()
		{
			return *_ptr;
		}
	private:
		unique_ptr(const unique_ptr<T>&) = delete;
		unique_ptr<T>& operator=(const unique_ptr<T>&) = delete;
	private:
		T* _ptr;
	};
}

当然unique_ptr在不拷贝的场景中可以使用，但是要是得拷贝的话它也就无能为力了

shared_ptr

C++11又提供了更靠谱的并且支持拷贝的shared_ptr

shared_ptr原理：通过引用计数的方式来实现多个shared_ptr对象之间共享资源

1. shared_ptr在其内部，给每个资源都维护了着一份计数，用来记录该份资源被几个对象共享。
2. 在对象被销毁时(也就是析构函数调用)，就说明自己不使用该资源了，对象的引用计数减一。
3. 如果引用计数是0，就说明自己是最后一个使用该资源的对象，必须释放该资源；
4. . 如果不是0，就说明除了自己还有其他对象在使用该份资源，不能释放该资源，否则其他对象就成野指针了。

template<class T>
	class shared_ptr{
	public:
		shared_ptr(T* ptr=nullptr)
			:_ptr(ptr)
			, _pCount(new int(1))
			, _mtx(new mutex)
		{}
		void AddUserCount()
		{
			// 加锁保证引用计数的线程安全
			unique_lock<mutex> lock(*_mtx);
			++(*_pCount);
		}
		shared_ptr(const shared_ptr<T>& sp)
			:_ptr(sp._ptr)
			, _pCount(sp._pCount)
			, _mtx(sp._mtx)
		{
			AddUserCount();
		}
		void Release()
		{
			bool flag = false;
			_mtx->lock();
			--(*_pCount);
			if (*_pCount == 0)
			{
				if (_ptr)
					delete _ptr;

				delete _pCount;
				flag = true;
			}
			_mtx->unlock();
			if (flag)
				delete _mtx;
		}
		shared_ptr<T>& operator=(const shared_ptr<T>& sp)
		{
			if (_ptr != sp._ptr)
			{
				// 释放旧资源
				this->Release();
				// 共享管理新对象的资源，并增加引用计数
				_ptr = sp._ptr;
				_pCount = sp._pCount;
				_mtx = sp._mtx;

				AddUserCount();
			}
			return *this;
		}

		~shared_ptr()
		{
			Release();
		}

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

	private:
		T* _ptr;
		int* _pCount;
		mutex* _mtx;
	};

其中要注意的有：1.为保证每份资源都有一个引用计数，我们让该引用计数存在于堆上；2. 引用计数的加减得保证其线程安全，注意：智能指针管理的资源不用保证线程安全，当然也保证不了；

用了shared_ptr还有没有内存泄漏的问题？？
答案是有的，这是shared_ptr的缺陷。（循环引用）
一张图带你弄懂循环引用：

为了解决循环引用，便提出了weak_ptr

weak_ptr

template <class T>
	class weak_ptr{
	public:
		weak_ptr()
			:ptr(nullptr)
		{}
		// 支持用shared_ptr拷贝构造
		weak_ptr(const shared_ptr<T> sp)
			:_ptr(sp.Get())
		{}

		weak_ptr& operator=(const shared_ptr<T>& sp)
		{
			_ptr = sp.Get();
			return *this;
		}
		T& operator*()
		{
			return _ptr;
		}

		T* operator->()
		{
			return _ptr
		}
		~weak_ptr()
		{
			if (_ptr)
				delete _ptr;
		}
	private:
		T* _ptr;
	};

解决办法就是：用weak_ptr去代替ListNode中的shared_ptr;

原理：weak_ptr只是用来保存shared_ptr的资源，支持shared_ptr给weak_ptr赋值，但是引用计数不会++

假设智能指针不是new出来的怎么办？？

	// shared_ptr<int> sp(int*(malloc(1)));

shared_ptr设计了一个删除器来解决这个问题：

// 仿函数的删除器
template<class T>
struct FreeFunc {
	void operator()(T* ptr)
	{
		free(ptr);
	}
};
template<class T>
struct DeleteArrayFunc {
	void operator()(T* ptr)
	{
		delete[] ptr;
	}
};
int main()
{
	FreeFunc<int> freeFunc;
	shared_ptr<int> sp1((int*)malloc(4), freeFunc);
	DeleteArrayFunc<int> deleteArrayFunc;
	shared_ptr<int> sp2((int*)malloc(4), deleteArrayFunc);
	return 0;
}

总结

• auto_ptr
  缺陷：两个智能指针的对象不能同时访问被管理资源。建议什么情况下都不要使用
• unique_ptr
  一份资源只能被一个对象管理。
  禁止拷贝和赋值，该智能指针可以使用，遗憾的是多个unique_ptr的对象之间不能共享资源
• shared_ptr
  优势：可以正常使用，多个对象之间可以共享资源
  缺陷：可能会导致循环引用，如果出现循环引用，采用weak_ptr配合解决