2. 程式人生 > >智慧指標二

智慧指標二

阿新 • • 發佈：2018-12-03

一、智慧指標：

1、智慧指標給出的原因

 

2、智慧指標原理

RAII：在建構函式中分配資源，在解構函式中釋放資源，可以進行解引用或者通過->訪問空間中的結構體變數。需要過載這幾個符號。（迭代器也是把指標進行了封裝、也進行了解引用、也進行了過載，所以迭代器也可以成為一種型別的智慧指標）

3、瞭解哪些智慧指標

迭代器也是把指標進行了封裝、也進行了解引用、也進行了過載，所以迭代器也可以成為一種型別的智慧指標

二、shared_ptr

1、ScopedPtr和sharedPtr在C++11中被加到了標準庫中，原理相同。ScopedPtr是boost庫裡面的，boost庫是c++中非常重要的一個庫，和標準庫一樣提供了一些非常重要的功能供大家呼叫，用到時候也是免費的。（當你在不是很瞭解boost庫裡面詳細的內容的時候，不要輕易說你瞭解ScopedPtr，因為你不瞭解其詳細內容）在標準庫中unique_ptr和其具有相同的功能，在unique_ptr管理資源只能管理一塊資源，只能被一個智慧指標的資源進行管理，不能幾個指標進行共享。其兩種實現方式在上一篇關於智慧指標的部落格中有講到.

 

template<class T>
class SharedPtr
{
public:
	//建構函式
	SharedPtr(T* ptr = NULL)//沒有傳任何實參時，預設值是空的
		:_ptr(ptr)//賦值給當前物件
		, _pCount(NULL)
	{
		if (_ptr)//如果不為空（即外部實參已經將資源給出來了）
		{
			_pCount = new int(1);//新申請一端空間，將空間中的內容給成1
			//給成1是因為外部使用者將資源給進來之後，當前只有一個物件進行管理
		}
	}
	//拷貝構造
	SharedPtr(const SharedPtr<T>& sp)
		:_ptr(sp._ptr)//共用同一塊空間
		, _pCount(sp._pCount)//共用同一塊引用計數
	{
		//智慧給當前物件的引用計數加1
		//當前物件如果存在，給引用計數++
		if (_pCount)
		{
			++(*_pCount);
		}
		//_pCount && ++(*_pCount);//不使用迴圈和if判斷實現上述方式
	}

	//賦值運算子的過載：sp1=sp2
	//可能會出現的情況：a、sp1為NULL；b、sp1管理了一段空間，但是這段空間
	//只是sp1一個物件在進行管理（資源獨佔）[應釋放sp1的空間，
	//在和sp2共用同一塊空間,引用計數++】；
	//c、sp1資源共享，【應將引用計數--】
	SharedPtr<T>& operator=(const SharedPtr<T>& sp)
	{
		if (this!=&sp)
		{
			//當前物件管理資源了，_pCount一定不為空
			//0==--(*_pCount說明當前物件自己獨立管理資源
			if (_pCount&&0==--(*_pCount)
			{
				delete _ptr;
				delete _pCount;
			}
			//當前物件在裡面沒有管理資源，但是也會共享同一塊引用計數
			_ptr = sp._ptr;
			_pCount = sp._pCount;
			if (_pCount)
				++(*_pCount);//共享同一塊空間需要將引用計數++
		}
		return *this;
	}
	//解構函式
	~SharedPtr()
	{
		if (_pCount && 0 == --(*_pCount))//當前物件獨立管理資源
		{
			delete _ptr;
			delete _pCount;
		}
	}
T& operator*()
	{
		return (*_ptr);
	}
	T& operator->()
	{
		return _ptr;
	}
	//
	int UseCount()const
	{
		return (*_pCount);
	}
private:
	T* _ptr;
	int *_pCount;//計數空間
};
void TestShared()
//sp1未管理資源
{
	SharedPtr<int> sp1;
	SharedPtr<int> sp2(new int);
	cout << sp2.UseCount() << endl;
	sp1 = sp2;
	cout << sp2.UseCount() << endl;
}
void TestShared1()
//測試獨立管理資源
{
	SharedPtr<int> sp1(new int);
	SharedPtr<int> sp2(new int);
	cout << sp2.UseCount() << endl;
	sp1 = sp2;
	cout << sp2.UseCount() << endl;
}
void TestShared2()
//sp1共享資源
{
	SharedPtr<int> sp1(new int);
	SharedPtr<int> sp2(new int);
	cout << sp2.UseCount() << endl;
	SharedPtr<int> sp3(sp1);//sp1和sp3共享空間
	sp1 = sp2;
	cout << sp2.UseCount() << endl;
}
int main()
{
	TestShared();
	return 0;
}

拷貝建構函式的思路：

存在問題，若是使用如下測試程式碼，程式會出錯：因為解構函式裡面直接對函式進行了delete操作，而此時我們建立新空間使用的是malloc

void TestShared3()
 {
	SharedPtr<int> sp1((int*)malloc(sizeof(int)));
	SharedPtr<FILE> sp2(fopen("1.txt","rb"));//rb按照只讀二進位制的形式開啟
 	SharedPtr<int> sp3(new int);//sp1和sp3共享空間
}

 不同的指標應該有不同的方式去處理指標的清理工作，

解決方式1：定製一個刪除器：

template<class T>
void DeletePtr(T*& ptr)
{
	if (ptr)
	{
		delete ptr;
		ptr = NULL;
	}
 }
//對於malloc申請的空間
template<class T>
void FreePtr(T*& ptr)
{
	if (ptr)
	{
		free(ptr);
		ptr = NULL;
	}
}
//檔案指標
void FClosedPtr(FILE*& ptr)
{
	if (ptr)
	{
		fclose(ptr);
		ptr = NULL;
	}
}

//給出函式指標
template<class T>
class _PDF
{
public:
	typedef void(*PDF)(T*&);//定義一個函式指標的型別
};


template<class T>
class SharedPtr
{
	typename typedef __PDF<T>::PDF PDF;
	//typename相當於告訴編譯器PDF是一個型別，不是靜態成員變數
public:
	//建構函式
	SharedPtr(T* ptr = NULL,PDF pdf=DeletePtr)//沒有傳任何實參時，預設值是空的
		:_ptr(ptr)//賦值給當前物件
		, _pCount(NULL)
                ,_pDf(pdf)
	{
		if (_ptr)//如果不為空（即外部實參已經將資源給出來了）
		{
			_pCount = new int(1);//新申請一端空間，將空間中的內容給成1
			//給成1是因為外部使用者將資源給進來之後，當前只有一個物件進行管理
		}
	}
	//拷貝構造
	SharedPtr(const SharedPtr<T>& sp)
		:_ptr(sp._ptr)//共用同一塊空間
		, _pCount(sp._pCount)//共用同一塊引用計數
	{
		//智慧給當前物件的引用計數加1
		//當前物件如果存在，給引用計數++
		if (_pCount)
		{
			++(*_pCount);
		}
		//_pCount && ++(*_pCount);//不使用迴圈和if判斷實現上述方式
	}

	//賦值運算子的過載：sp1=sp2
	//可能會出現的情況：a、sp1為NULL；b、sp1管理了一段空間，但是這段空間
	//只是sp1一個物件在進行管理（資源獨佔）[應釋放sp1的空間，
	//在和sp2共用同一塊空間,引用計數++】；
	//c、sp1資源共享，【應將引用計數--】
	SharedPtr<T>& operator=(const SharedPtr<T>& sp)
	{
		if (this!=&sp)
		{
			//當前物件管理資源了，_pCount一定不為空
			//0==--(*_pCount說明當前物件自己獨立管理資源
			if (_pCount&&0==--(*_pCount)
			{
				//delete _ptr;
                                _pDf(_ptr);
				delete _pCount;
			}
			//當前物件在裡面沒有管理資源，但是也會共享同一塊引用計數
			_ptr = sp._ptr;
			_pCount = sp._pCount;
			if (_pCount)
				++(*_pCount);//共享同一塊空間需要將引用計數++
		}
		return *this;
	}
	//解構函式
	~SharedPtr()
	{
		if (_pCount && 0 == --(*_pCount))//當前物件獨立管理資源
		{
			//delete _ptr;
                        _pDf(_ptr);
			delete _pCount;
		}
	}
	T& operator*()
	{
		return (*_ptr);
	}
	T& operator->()
	{
		return _ptr;
	}
	//
	int UseCount()const
	{
		return (*_pCount);
	}
private:
	T* _ptr;
	int *_pCount;//計數空間
        PDF _pDF;
};
void TestShared()
//sp1未管理資源
{
	SharedPtr<int> sp1;
	SharedPtr<int> sp2(new int);
	cout << sp2.UseCount() << endl;
	sp1 = sp2;
	cout << sp2.UseCount() << endl;
}
void TestShared1()
//測試獨立管理資源
{
	SharedPtr<int> sp1(new int);
	SharedPtr<int> sp2(new int);
	cout << sp2.UseCount() << endl;
	sp1 = sp2;
	cout << sp2.UseCount() << endl;
}
void TestShared2()
//sp1共享資源
{
	SharedPtr<int> sp1(new int);
	SharedPtr<int> sp2(new int);
	cout << sp2.UseCount() << endl;
	SharedPtr<int> sp3(sp1);//sp1和sp3共享空間
	sp1 = sp2;
	cout << sp2.UseCount() << endl;
}
void TestShared3()
 {
	SharedPtr<int> sp1((int*)malloc(sizeof(int)),FreePtr);
	SharedPtr<int> sp2(fopen("1.txt","rb"),FClosedPtr);//rb按照只讀二進位制的形式開啟
 	SharedPtr<int> sp3(new int);//sp1和sp3共享空間
}
int main()
{
	TestShared3();
	return 0;
}

解決方式2：加上一個模板型別的引數

//函式引數
//相當於把Dx建立的無名物件像函式一樣使用（即仿函式）：
//只需要在類裡面過載（）
template<class T>
class Delete
{
public:
	//過載()
	void operator()(T*& ptr)
	{
		if (ptr)
		{
			delete ptr;
			ptr = NULL;
		}
	}
};
template<class T>
class Free
{
public:
	void operator()(T*& ptr)
	{
		if (ptr)
		{
			free(ptr);
			ptr=NULL:
		}
	}
};
//檔案指標的類，本身就是FILE*，不需要給成模板類
class FClose
{
public:
	void operator()(FILE*& ptr)
	{
		if (ptr){
			fclose(ptr);
			ptr = NULL;
		}
	}
};
template<class T，class Dx=Delete<T>>//此時Dx是一個型別
class SharedPtr
{
public:
	//建構函式
	SharedPtr(T* ptr = NULL)//沒有傳任何實參時，預設值是空的
		:_ptr(ptr)//賦值給當前物件
		, _pCount(NULL)
	{
		if (_ptr)//如果不為空（即外部實參已經將資源給出來了）
		{
			_pCount = new int(1);//新申請一端空間，將空間中的內容給成1
			//給成1是因為外部使用者將資源給進來之後，當前只有一個物件進行管理
		}
	}
	//拷貝構造
	SharedPtr(const SharedPtr<T>& sp)
		:_ptr(sp._ptr)//共用同一塊空間
		, _pCount(sp._pCount)//共用同一塊引用計數
	{
		//智慧給當前物件的引用計數加1
		//當前物件如果存在，給引用計數++
		if (_pCount)
		{
			++(*_pCount);
		}
		//_pCount && ++(*_pCount);//不使用迴圈和if判斷實現上述方式
	}

	//賦值運算子的過載：sp1=sp2
	//可能會出現的情況：a、sp1為NULL；b、sp1管理了一段空間，但是這段空間
	//只是sp1一個物件在進行管理（資源獨佔）[應釋放sp1的空間，
	//在和sp2共用同一塊空間,引用計數++】；
	//c、sp1資源共享，【應將引用計數--】
	SharedPtr<T>& operator=(const SharedPtr<T>& sp)
	{
		if (this!=&sp)
		{
			//當前物件管理資源了，_pCount一定不為空
			//0==--(*_pCount說明當前物件自己獨立管理資源
			if (_pCount&&0==--(*_pCount)
			{
				Dx()(_ptr);//直接加上（）相當於建立了一個物件
				//類似於一個函式物件
				delete _pCount;
			}
			//當前物件在裡面沒有管理資源，但是也會共享同一塊引用計數
			_ptr = sp._ptr;
			_pCount = sp._pCount;
			if (_pCount)
				++(*_pCount);//共享同一塊空間需要將引用計數++
		}
		return *this;
	}
	//解構函式
	~SharedPtr()
	{
		if (_pCount && 0 == --(*_pCount))//當前物件獨立管理資源
		{
			Dx()(_ptr);//直接加上（）相當於建立了一個物件
				//類似於一個函式物件
			delete _pCount;
		}
	}
	T& operator*()
	{
		return (*_ptr);
	}
	T& operator->()
	{
		return _ptr;
	}
	//
	int UseCount()const
	{
		return (*_pCount);
	}
private:
	T* _ptr;
	int *_pCount;//計數空間
};
void TestShared()
{
	SharedPtr<int,Free<int>> sp1((int*)malloc(sizeof(int)));
	SharedPtr<FILE,FClose> sp2(fopen("1.txt", "rb"));//rb按照只讀二進位制的形式開啟
	SharedPtr<int> sp3(new int);//sp1和sp3共享空間
}

int main()
{
	TestShared();
	return 0;
}

3、使用標準庫中的shared_ptr處理問題：

int main()
{
	shared_ptr<int> sp1(new int);//管理單個的空間
	cout << sp1.use_count() << endl;
	//sp1拷貝構造sp2
	shared_ptr<int> sp2(sp1);
	cout << sp1.use_count() << endl;
	return 0;
}

4、shared_ptr自身有一個很大的缺陷，有可能存在迴圈引用的問題，沒有呼叫解構函式，會發生記憶體洩漏，如下述程式：

# include"memory"
template<class T>
struct ListNode
{
	//建構函式
	ListNode(const T& data)
	:_pPre(NULL)
	, _pNext(NULL)
	, _data(data)
	{
		cout << "ListNode(const T&):" << this << endl;
	}
	~ListNode()
	{
		cout << "~ListNode():" << this<<endl;
	}
	//ListNode<T>* _pPre;
	//ListNode<T>* _pNext;
	shared_ptr<ListNode<T>> _pPre;
	shared_ptr < ListNode<T>> _pNext;
	T _data;
};
void TestSharedPtr()
{
	//ListNode<int>* p=new ListNode<T> (10);
	shared_ptr<ListNode<int>> sp1(new ListNode<int> (10));
	shared_ptr<ListNode<int>> sp2(new ListNode<int>(20));
	cout << sp1.use_count() << endl;
	cout << sp2.use_count() << endl;
	//將兩個節點連結起來
	sp1->_pNext = sp2;
	sp2->_pPre = sp1;
	cout << sp1.use_count() << endl;
	cout << sp2.use_count() << endl;
}
int main()
{
	TestSharedPtr();
	system("pause");
	return 0;
}

結果為2，沒有進行析構、釋放

5、解決迴圈引用的問題：weak_ptr，weak_ptr不能獨立的管理空間。和shared_ptr一起使用，解決迴圈引用的問題,此時會呼叫解構函式【迴圈引用的場景，面試重要程度：5顆星】

# include"memory"
template<class T>
struct ListNode
{
	//建構函式
	ListNode(const T& data)
	:_data(data)
	{
		cout << "ListNode(const T&):" << this << endl;
	}
	~ListNode()
	{
		cout << "~ListNode():" << this<<endl;
	}
	//ListNode<T>* _pPre;
	//ListNode<T>* _pNext;
	weak_ptr<ListNode<T>> _pPre;
	weak_ptr < ListNode<T>> _pNext;
	T _data;
};
void TestSharedPtr()
{
	//weak_ptr<int> wp(new int);//不能單獨使用，必須依附在shared_ptr之上
	//ListNode<int>* p=new ListNode<T> (10);
	shared_ptr<ListNode<int>> sp1(new ListNode<int> (10));
	shared_ptr<ListNode<int>> sp2(new ListNode<int>(20));
	cout << sp1.use_count() << endl;
	cout << sp2.use_count() << endl;
	//將兩個節點連結起來
	sp1->_pNext = sp2;
	sp2->_pPre = sp1;
	cout << sp1.use_count() << endl;
	cout << sp2.use_count() << endl;
}
int main()
{
	TestSharedPtr();
	system("pause");
	return 0;
}

結果：

 

相關推薦

智慧指標二

一、智慧指標： 1、智慧指標給出的原因   2、智慧指標原理 RAII：在建構函式中分配資源，在解構函式中釋放資源，可以進行解引用或者通過->訪問空間中的結構體變數。需要過載這幾個符號。（迭代器也是把指標進行了封裝、也進行了解引用、也進行了過載，所以迭代器也可以成為一

十三、智慧指標二

1、SmartPointer智慧指標重構 需求：使用智慧指標SmartPointer替換單鏈表LinkList中的原生指標 將原生指標更改為智慧指標後，解決全部的編譯問題，程式還是會出錯，問題在於：SmartPointer的設計方案存在的一些特性 指標的生命週期結束時主動釋放堆空間 一片堆空間最多隻能有

筆記十二：智慧指標（二）

導語： 在智慧指標（一） 中講解了智慧指標的實現方式一，即僱傭一個使用計數類記錄共享物件。現在講解智慧指標的另一種實現方式，控制代碼形式的智慧指標。在介紹控制代碼形式的智慧指標之前，先介紹代理類。 代理類： 1、現假設存在一個基類和它的派生類，設計如下

Boost庫學習筆記（二）- 智慧指標

概述 1.智慧指標的原理基於一個常見的習語叫做 RAII ：資源申請即初始化。 2.智慧指標確保在任何情況下，動態分配的記憶體都能得到正確釋放，從而將開發人員從這項任務中解放了出來。 這包括程式因為異常而中斷，原本用於釋放記憶體的程式碼被跳過的場景。 3.一個作用域指標不能傳遞它所包含的

Android架構分析之Android智慧指標（二）

作者：劉昊昱  Android版本：4.4.2 在上一篇文章中，我們分析了Android智慧指標中的強指標sp，本文我們來分析弱指標wp。為什麼需要弱指標wp呢？我們來考慮下面一種場景：有兩個類CParent和CChild，CParent類中有一個智慧指標指向CChil

小和尚上山學習之智慧指標（二）--boost::scoped_ptr

boost::scoped_ptr：屬於 boost 庫，定義在 namespace boost 中，包含標頭檔案 #include<boost/smart_ptr.hpp> 便可以使用。boost::scoped_ptr 跟 std::auto_ptr 一樣，可

一步一步 實現智慧指標（二）

 假如我要做一個對Point類的智慧指標 。 程式碼實現 usingnamespace std; class Point { private: //public:     int x;     int y; public:     Point(int xVal,

boost庫在工作（9）引用計數的智慧指標shared_ptr之二

接著下來，需要演示一下怎麼樣在多個物件裡共享一個物件，而不管每個物件的生命週期，就可以及時地把使用的物件在合適地方刪除。下面的例子裡先定義兩個類，然後每個類都引用共享的物件，接著使用完成後，就會在解構函式裡刪除，可以從例子程式執行的輸出結果看到內部執行的生命週期。有了共享智慧

C++深度探索系列：智慧指標(Smart Pointer) [二]

                                           深度探索智慧指標(Smart Pointer) 主題索引： 一、剖析C++標準庫智慧指標(std::auto_ptr)        1.Do you Smart Pointer?    2

智慧指標和二叉樹(2):資源的自動管理

上一篇文章中我們提到了用智慧指標構建二叉樹來減輕我們的工作負擔。今天我們來討論下稍微複雜的情況下如何藉助智慧指標管理資源。 一般來說，當我們在程式中使用了智慧指標後就無需親自過問資源管理的問題了。然而隨著資料結構和演算法逐漸變得複雜，資源之間的關係也可能不再是簡單的共享，比如下面的例子。 誤用shared_p

智慧指標和二叉樹(3):圖解查詢和刪除

在前兩篇文章中我們詳細介紹了使用智慧指標構建二叉樹並進行了層序遍歷。 現在我們已經掌握了足夠的前置知識，可以深入瞭解二叉搜尋樹的查詢和刪除了。 本文索引 二叉搜尋樹的查詢 查詢最小值和最大值 查詢特定值

c++11新特性實戰（二）：智慧指標

## c++11新特性實戰（二）：智慧指標 c++11添加了新的智慧指標，unique_ptr、shared_ptr和weak_ptr，同時也將auto_ptr置為廢棄(deprecated)。 但是在實際的使用過程中，很多人都會有這樣的問題： 1. 不知道三種智慧指標的具體使用場景 2. 無腦只使用

條款17：以獨立語句將newed物件置入智慧指標

條款17：以獨立語句將newed物件置入智慧指標 如何理解這句話呢？先上程式碼 class Queue { public: Queue() {} ~Queue() {} }; int GetPriority(const int type) {return

1.1 c/c++智慧指標

c/c++智慧指標 (直接上程式碼) template <typename T> class sharePtr { public: sharePtr() { instance_ = new T(); } ~sharePtr() { delete instan

C++ 智慧指標詳解

C++ 智慧指標詳解   一、簡介 由於 C++ 語言沒有自動記憶體回收機制，程式設計師每次 new 出來的記憶體都要手動 delete。程式設計師忘記 delete，流程太複雜，最終導致沒有 de

【轉載】C++ 智慧指標（shared_ptr/weak_ptr）原始碼分析

發現一篇對C++11智慧指標分析很透徹的文章，特轉載備忘！ 以下轉載自：https://blog.csdn.net/ithiker/article/details/51532484?utm_source=blogxgwz1   C++11目前已經引入了unique_ptr, shared_pt

effective c++條款17：以獨立語句將newed物件置入智慧指標

假設有這麼一個函式process，它接收一個MyClass型別的指標與 一個函式，如果按下面的方式呼叫： #include <iostream> #include <memory> using namespace std; class MyClass { p

c++11： 智慧指標 shared_ptr & unique_ptr

一、背景 1. 堆記憶體、棧記憶體、靜態區記憶體 我們知道，靜態記憶體用來儲存區域性 static 物件、類 static 資料成員以及定義在函式之外的變數。而棧記憶體用來儲存定義在函式內的非 static 物件。 分配在靜態區或棧記憶體中的物件由編譯器自動建立和銷燬，對於棧

C++之智慧指標std::shared_ptr簡單使用和理解

1  智慧指標std::shared_ptr相關知識和如何使用 我們這裡先說下智慧指標std::shared_ptr,因為我看到我我們專案c++程式碼裡面用得很多,我不是不會,所以記錄學習下 先讓ubuntu終端支援c++11,如果自己的電腦還沒配置號,可以先看下我的這篇部落格

C++ 自己實現智慧指標（輕量級）

文章目錄 引入 c++中間類 改進-增加引用計數 再次改進--使用模板template 再次改進--引用計數增加原子操作 引入 c++的堆和棧 class Person{ public: