智能指針的原理及其應用

所謂智能指針就是自動化管理指針所指向的動態資源的釋放。

那么智能指針的引用是為了解決哪些問題呢？

代碼中經常會忘掉釋放動態開辟的資源，引用智能指針可用于動態資源管理，資源分配即初始化，定義一個類來封裝資源的分配和釋放，在構造函數中完成資源的分配和初始化，在析構函數完成資源的清理，可以保證資源的正確初始化和釋放。

智能指針的原理：智能指針是一個類，這個類的構造函數中傳入一個普通指針，析構函數中釋放傳入的指針。智能指針的類是棧上的對象，智能指針指向堆上開辟的空間，函數結束時，棧上的函數會自動被釋放，智能指針指向的內存也會隨之消失，防止內存泄漏。

智能指針的實現需要實現構造、析構、拷貝構造、操作符重載。

幾種常見的智能指針的區別？

auto_ptr：就是內部使用一個成員變量指向一塊內存資源（構造函數），并且在析構函數中釋放內存資源。auto_ptr的拷貝構造和賦值操作符重載函數所接受的參數都是非const的引用類型（即我們可以且修改資源），不能共享所有權（其它任意一個指針指向這塊內存，它會把內存給別的指針，自己不指向了）。權限轉移。

template <typename T>
class Auto_Ptr
{
public:
	Auto_Ptr(T *ptr = NULL)
		:_ptr(ptr)
	{}
	~Auto_Ptr()
	{
		if (_ptr != NULL)
		{
			delete _ptr;
			cout<<"~Auto_Ptr()"<<endl;
		}
	}
	Auto_Ptr(Auto_Ptr<T> &ap)
		:_ptr(ap._ptr)
	{
		ap._ptr = NULL;
	}
	Auto_Ptr<T> &operator= (Auto_Ptr<T> &ap)
	{
		if (this != &ap)
		{
			delete _ptr;
			_ptr = ap._ptr;
			ap._ptr = NULL;
		}
		return *this;
	}
private:
	T *_ptr;
};

void Test1()
{
	Auto_Ptr<int> a1(new int(1));
	Auto_Ptr<int> a2(a1);
	Auto_Ptr<int> a3(new int(2));
	a1 = a1;
	a2 = a3;
}

scoped_ptr有著與auto_ptr類似的特性，scoped_ptr與auto_ptr最大的區別主要在于對內存資源擁有權的處理。（auto_ptr在拷貝構造時會從源auto_ptr自動交出擁有權，而scoped_ptr則不允許被拷貝）。scoped_ptr不能資源共享。

template <typename T>
class Scoped_Ptr
{
public:
	Scoped_Ptr(T *ptr)
		:_ptr(ptr)
	{}
	~Scoped_Ptr()
	{
		if (_ptr != NULL)
		{
			delete _ptr;
			cout<<"~Scoped_Ptr()"<<endl;
		}
	}

private:
	Scoped_Ptr(const Scoped_Ptr<T> &sp);
	Scoped_Ptr<T> &operator=(const Scoped_Ptr<T> &sp);
	T *_ptr;
};

void Test2()
{
	Scoped_Ptr<int> s1(new int(1));
	//Scoped_Ptr<int> s2(s1);
	Scoped_Ptr<int> s3(new int(2));
	//s1 = s1;
	//s2 = s3;
}

shared_ptr就是為了解決auto_ptr在對象所有權上的局限性，在使用引用計數的基礎上提供了可以共享所有權的智能指針。當新增一個shared_ptr對該對象進行管理時，就將該對象的引用計數加一，同理減少一個時，計數器減一。當該對象的引用計數器為0時，調用delete釋放其所占的內存。

template <typename T>
class Shared_Ptr
{
public:
	Shared_Ptr(T *ptr)
		:_ptr(ptr)
		,_count(new int(1))
	{}
	~Shared_Ptr()
	{
		if(--(*_count) == 0)
		{
			delete _ptr;
			delete _count;
			cout<<"~Shared_Ptr()"<<endl;
		}
		(*_count)--;
	}
	Shared_Ptr(Shared_Ptr<T> &sp)
		:_ptr(sp._ptr)
		,_count(sp._count)
	{
		(*_count)++;
	}
	Shared_Ptr<T> &operator=(Shared_Ptr<T> &sp)
	{
		if (this != &sp)
		{
			if (--(*_count) == 0)
			{
				delete _ptr;
				delete _count;
			}
			_ptr = sp._ptr;
			_count = sp._count;
			(*_count)++;
		}
		return *this;
	}
private:
	T *_ptr;
	int *_count;
};

void Test3()
{
	Shared_Ptr<int> s1(new int(1));
	Shared_Ptr<int> s2(s1);
	Shared_Ptr<int> s3(new int(2));
	s1 = s1;
	s1 = s3;
}

shared_ptr存在循環引用的問題，使用weak_ptr可以用來避免循環引用。但是weak_ptr對象引用資源時不會增加引用計數，無法知道資源會不會被突然釋放，所以無法通過weak_ptr訪問資源。在訪問資源時weak_ptr必須先轉化為shared_ptr。

#include <iostream>
#include <boost/shared_ptr.hpp>
#include <boost/weak_ptr.hpp>
using namespace std;
using namespace boost;
struct ListNode
{
	shared_ptr<ListNode > _prev;
	shared_ptr<ListNode > _next;
	//weak_ptr<ListNode > _prev;
	//weak_ptr<ListNode > _next;
	~ ListNode()
	{
		cout<<"~ListNode()" <<endl;
	}
};
void Test ()
{
// 循環引用問題
	shared_ptr <ListNode > p1( new ListNode ());
	shared_ptr <ListNode > p2( new ListNode ());
	cout <<"p1->Count:" << p1. use_count()<<endl ;
	cout <<"p2->Count:" << p2. use_count()<<endl ;
	// p1節點的_next指向 p2節點
	p1->_next = p2;
	// p2節點的_prev指向 p1節點
	p2->_prev = p1;
	cout <<"p1->Count:" << p1. use_count ()<<endl ;
	cout <<"p2->Count:" << p2. use_count ()<<endl ;
}