c++智能指针

     我们在编写c++程序时经常会面临内存泄漏的问题，例如

void f()
{
	int* p = new int;
	throw "unknow exception";
    delete p;
}

在这个简单的函数中，我们申请了一块内存，但是因为抛出异常跳出函数执行catch函数，导致new出来的内存没有释放掉。但是如果我们使用智能指针就可以避免这种问题。

我们先来看一下c++98中的auto_ptr(源码简化版)

namespace nyk {
	template<class T>
	class auto_ptr {
	public:
		auto_ptr(T* p = nullptr) :_ptr(p)
		{
		}
		auto_ptr(auto_ptr<T>& p)
		{
			this->_ptr = p._ptr;
			p._ptr = nullptr;
		}
		auto_ptr& operator=(auto_ptr<T>& p)
		{
            if(this!=&p){
            if(_ptr)//释放当前对象中的资源
               delete _ptr;
			this->_ptr = p._ptr;
			p._ptr = nullptr;
			return *this;
          }  
		}
		T& operator*()
		{
			return *(_ptr);
		}
		T* operator->()
		{
			return _ptr;
		}
		~auto_ptr()
		{
            if(_ptr)
			delete _ptr;
		}
	private:
		T* _ptr;
	};
}

封装一个类里面存放指针，在离开函数作用域的时候自动调用析构函数，这样就可以防止内存泄漏。

void f()
{
	nyk::auto_ptr<int>p(new int(10));
	throw invalid_argument("unknow exc");
}

同时为了防止拷贝构造时一块空间被多个对象使用而造成程序崩溃，将当前对象的指针指向空。

但是在拷贝过后会将被拷贝的对象悬空，如下p在拷贝后就会悬空，如果此时使用p来访问资源就会出现问题。

nyk::auto_ptr<int>p(new int(10));
	nyk::auto_ptr<int>q(p);

在c++11中提供了更靠谱的智能指针（unique_ptr ,shared_ptr ,weak_ptr)。

unique_ptr的实现原理：简单粗暴的防拷贝（与auto_ptr相比直接把拷贝构造封死）

template<class T>
class UniquePtr
{
public:
 UniquePtr(T * ptr = nullptr) 
 : _ptr(ptr)
 {}
 ~UniquePtr() 
 {
 if(_ptr)
 delete _ptr;
 }
 T& operator*() {return *_ptr;}
 T* operator->() {return _ptr;}
 
private:
 // C++98防拷贝的方式：只声明不实现+声明成私有
 UniquePtr(UniquePtr<T> const &);
 UniquePtr & operator=(UniquePtr<T> const &);
 
 // C++11防拷贝的方式：delete
 UniquePtr(UniquePtr<T> const &) = delete;
 UniquePtr & operator=(UniquePtr<T> const &) = delete;
 
private:
 T * _ptr;
};

更靠谱并且支持拷贝的shared_ptr的实现原理：通过引用计数实现多个对象共享资源。

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

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

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

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

shared_ptr模拟实现（多线程不安全）如果考虑多线程需要自己加锁。

	template<class T>
	class shared_ptr {
	public:
		shared_ptr(T* p = nullptr) :_ptr(p),cnt(new int(1))
		{
		}
		shared_ptr(shared_ptr<T>& p)
		{
			this->_ptr = p._ptr;
			this->cnt = p.cnt;
			++(*cnt);
		}
		shared_ptr& operator=(shared_ptr<T>& p)
		{
			if (_ptr != p._ptr)
			{
				Release();
				// 共享管理新对象的资源，并增加引用计数
				_ptr = p._ptr;
				cnt = p.cnt;
				++(*cnt);
			}
		}
		T& operator*()
		{
			return *(_ptr);
		}
		T* operator->()
		{
			return _ptr;
		}
		int Usecnt()
		{
			return *cnt;
		}
		T* Get() { return _ptr };
		~shared_ptr()
		{
			delete _ptr;
		}
	private:
		void Release()
		{
			//bool deleteflag = false;用于多线程模式下删除锁
			// 引用计数减1，如果减到0，则释放资源
			if (--(*cnt) == 0)
			{
				delete _ptr;
				delete cnt;
				deleteflag = true;
			}

			//if (deleteflag == true)
			//	delete _pMutex;
		}
		T* _ptr;
		int* cnt;
        mutex* _pMutex;//多线程锁
	};

但是shared_ptr也有一个致命的缺点

struct ListNode
{
 int _data;
 shared_ptr<ListNode> _prev;
 shared_ptr<ListNode> _next;
 ~ListNode(){ cout << "~ListNode()" << endl; }
};
int main(){
 shared_ptr<ListNode> node1(new ListNode);
 shared_ptr<ListNode> node2(new ListNode);
 node1->_next = node2;
 node2->_prev = node1;
}

在这个双向链表中node1与node2相互引用的过程分析：

1. node1和node2两个智能指针对象指向两个节点，引用计数变成1，我们不需要手动delete。

2.node1的_next指向node2，node2的_prev指向node1，引用计数变成2。

3. node1和node2析构，引用计数减到1，但是_next还指向下一个节点。但是_prev还指向上一个节点。

4. 也就是说_next析构了，node2就释放了。

5. 也就是说_prev析构了，node1就释放了。

6但是_next属于node的成员，node1释放了，_next才会析构，而node1由_prev管理，_prev属于node2 成员，所以这就叫循环引用，谁也不会释放。

所以在这个时候出现了weak_ptr,weak_ptr只共享资源并不增加引用计数。在析构时并不释放资源，如果我们将node中的shared_ptr替换为weak_ptr就可以解决这个问题了。

有了前面的铺垫，weak_ptr就比较简单了，可以自己实现一下。