1.什麼是智慧指標?

C++智慧指標是行為類似於指標的類物件。它使用設計模式中的代理模式，代理了原始“裸”指標的行為，為指標添加了更多更有用的特性。C++引入異常機制後，智慧指標由一種技巧升級為一種非常重要的技術，因為如果沒有智慧指標程式設計師必須保證new物件能在正確的時機delete，四處編寫異常捕獲程式碼釋放資源，而智慧指標則可以在退出作用域時—
—不管是正常離開或是因異常離開——總呼叫delete來析構在堆疊上動態分配的物件。因為C++異常處理的真正功能在於它具有為異常拋擲前構造的所有區域性物件(那麼智慧指標物件也適用)自動呼叫解構函式的能力（C++異常機制不僅僅在於它能夠處理各種不同型別的異常）。所以在異常退出智慧指標物件作用域時，總能由C++異常機制呼叫解構函式釋放在堆疊上動態分配的物件。當然，正常退出物件（智慧指標物件也屬於此列）作用域也會自動呼叫解構函式釋放在堆疊上動態分配的物件。由此可知，將“裸”指標包裝成智慧指標物件可以實現動態分配的記憶體物件的自動釋放。而C++智慧指標物件可以像原指標那樣直接使用運算子，如賦值運算子'='，指標運算子'->'，解引用運算子'*'。這點從”shared_ptr智慧指標--shared_ptr模板類摘要“部分可以印證。

2.VS2008 sp1下使用智慧指標:

標頭檔案:<memory>

作用域:std::tr1::

3.自己實現智慧指標:

我們的智慧指標類是儲存在堆中分配的物件指標的類。利用物件生存期實現對記憶體的自動控制,保證記憶體能夠被正常釋放，防止記憶體洩露。我們的智慧指標物件可以賦值給另一個智慧指標物件,實現對同一塊記憶體的引用.我們在我們的類中新增一個引用計數類,這個類儲存實際指向的記憶體地址的指標和引用計數.這樣，當智慧指標物件呼叫建構函式建立時,我們將引用計數加1;當呼叫拷貝建構函式時,將引用計數加1;當呼叫=賦值時,我們將操作右值物件(賦值的智慧指標物件)引用計數加1.將左值物件(被賦值的智慧指標物件)引用計數減1(因為這個智慧指標物件不再引用原來的物件了,所以需要將計數減1,並判斷引用計數決定是否delete 引用計數指標

具體實現:

template <class T>
class Auto_Ptr;

// 智慧指標引用計數類
template <class T>
class Ref_Ptr
{
	friend class Auto_Ptr<T>;
private:
	T* m_pTtr; // 實際的指標
	size_t m_RefCount; // 引用計數
	Ref_Ptr(T* p);
	virtual ~Ref_Ptr();
};

template <class T>
Ref_Ptr<T>::Ref_Ptr(T* p)
{
	m_pTtr = p;
	m_RefCount = 1;
	printf("Ref_Ptr() 建構函式呼叫!\r\n");
}

template <class T>
Ref_Ptr<T>::~Ref_Ptr()
{
	if (m_pTtr)
	{
		printf("~Ref_Ptr() 解構函式函式呼叫");
		delete m_pTtr;
		m_RefCount =0;
	}
	m_pTtr = NULL;
}

// 智慧指標物件
template <class T>
class Auto_Ptr
{
private:
	Ref_Ptr<T>* m_pRef; // 引用計數
public:
	Auto_Ptr();
	Auto_Ptr(T* p);
	~Auto_Ptr();
	// 過載運算=,將左物件引用計數-1,並判斷是否delete;將右物件+1;
	Auto_Ptr<T> & operator = (Auto_Ptr& other);
	// 過載指標操作*,->
	T& operator *();
	T* operator ->();
	// 拷貝建構函式,引用計數+1
	Auto_Ptr(Auto_Ptr<T>& other);
};
template <class T>
Auto_Ptr<T>::Auto_Ptr()
{
	m_pRef = NULL;
}

template<class T>
Auto_Ptr<T>::Auto_Ptr(T* p)
{
	m_pRef = new Ref_Ptr<T>(p);
	printf("Auto_Ptr(T* p) 建構函式呼叫\r\n");
}

template <class T>
Auto_Ptr<T>::Auto_Ptr(Auto_Ptr<T>& other)
{
	this->m_pRef = other.m_pRef;
	++(m_pRef->m_RefCount);
	printf("Auto_Ptr(& other) 拷貝建構函式被呼叫,當前引用計數%d", this->m_pRef->m_RefCount);
}

template <class T>
Auto_Ptr<T>& Auto_Ptr<T>::operator=(Auto_Ptr& other)
{
	// 將右操作物件引用計數+1
	++(other.m_pRef->m_RefCount);

	// 由於左操作物件指向了新物件,需要將運算元-1;
	// 同時也防止了自賦值的方式.
	// 首先要判斷這個物件是否已經指向了其他物件,這個很重要!防止左指標物件為null的情況.
	if (this->m_pRef)
	{
		if (--(this->m_pRef->m_RefCount) == 0)
		{
			delete this->m_pRef;
		}
	}

	this->m_pRef = other.m_pRef;
	printf("operator = 被呼叫,當前引用計數%d", this->m_pRef->m_RefCount);
	return *this;
}

template <class T>
T& Auto_Ptr<T>::operator *()
{
	return *(m_pRef->m_pTtr);
}

template <class T>
T* Auto_Ptr<T>::operator->()
{
	return (m_pRef->m_pTtr);
}

template <class T>
Auto_Ptr<T>::~Auto_Ptr()
{
	printf("~Auto_Ptr() 解構函式被呼叫\r\n");
	if ((--m_pRef->m_RefCount) == 0)
	{
		printf("刪除\r\n");
		delete m_pRef;
		m_pRef = NULL;
	}
	if (m_pRef)
	{
			printf("當前引用計數:%d", m_pRef->m_RefCount);
	}
}
 

C++智慧指標物件類似於java裡的垃圾回收機制,同樣利用引用計數.

測試程式:

int _tmain(int argc, _TCHAR* argv[])
{
	Auto_Ptr<int>* pPtr = NULL;
	{
		Auto_Ptr<int> g_ptr;
		{
			// 宣告一個ptr1智慧指標,並測試*運算子
			Auto_Ptr<int> ptr1(new int(4));
			printf("%d\r\n", *ptr1);
			// 將生存期小的ptr1賦值給生存期更大的g_ptr;
			g_ptr = ptr1;
		}
		// new int(4)並沒有銷燬,因為引用計數還有1個
		Auto_Ptr<int> ptr2(new int(3));
		g_ptr = ptr2; // 此時將g_ptr指向一個新的智慧指標物件,原引用計數-1,銷燬了.(可以看到賦值左減的重要性)
		// 這個測試的是指向區域性智慧指標物件的智慧物件指標,果然是有問題的;
		// 相當於指向區域性變數地址的指標.
		Auto_Ptr<int>* pPtr = &ptr2;
		printf("%d\r\n", *(*pPtr));
	}
	Sleep(2000);
	// 錯誤,區域性物件的指標已經釋放!!!!
	//printf("%d\r\n", *(*pPtr));
	getchar();
	return 0;
}