C/C++智能指针
目錄
1.1RAII(資源獲取幾初始化)
?1.2auto_ptr
1.3unique_ptr
1.5weak_ptr
?我們?cè)谠趧?dòng)態(tài)開辟空間的時(shí)候，malloc出來的空間如果沒有進(jìn)行釋放，那么回傳在內(nèi)存泄漏問題?；蛘咴趍alloc與free之間如果存在拋異常，那么還是有內(nèi)存泄漏安全。因此我們?cè)谶@里引入了智能指針來對(duì)資源進(jìn)行管理。（內(nèi)存泄漏）
1.1RAII(資源獲取及初始化)
RAII（Resource Acquisition Is Initialization）是一種利用對(duì)象生命周期來控制程序資源（如內(nèi)存、文件句柄、網(wǎng)絡(luò)連接、互斥量等等）的簡單技術(shù)。 在對(duì)象構(gòu)造時(shí)獲取資源，接著控制對(duì)資源的訪問使之在對(duì)象的生命周期內(nèi)始終保持有效，最后在對(duì)象析構(gòu)的時(shí)候釋放資源。借此，我們實(shí)際上把管理一份資源的責(zé)任托管給了一個(gè)對(duì)象。這種做法的好處：
- 不需要顯示的釋放資源。
- 采用這種方式，對(duì)象所需要的資源在其生命期內(nèi)始終保持有效。
總結(jié)：RAII就是一種管理資源自動(dòng)釋放的一種機(jī)制，初步看來，他通過類將資源包裝起來。在進(jìn)行資源初始化時(shí)，巧妙地利用編譯器會(huì)自動(dòng)調(diào)用構(gòu)造函數(shù)預(yù)計(jì)析構(gòu)函數(shù)的特性，來完成對(duì)資源的自動(dòng)釋放。在構(gòu)造方法中，將資源放入，讓對(duì)象進(jìn)行釋放，在析構(gòu)方法中，將資源釋放掉。
#include<iostream> using namespace std; //智能指針的原理：RAII+具有指針類似的行為 //我們?cè)谶@里自己進(jìn)行封裝 template<class T> class Smartptr{ public:Smartptr(T* p = nullptr) :ptr(p){}~Smartptr(){if (ptr){//此時(shí)指針如果不為空且具有釋放的權(quán)利的時(shí)候，則將其釋放，且將owner重新職位falsedelete ptr;ptr = nullptr;}}//在使用指針是我們有*與->的使用，因此在這里要對(duì)齊進(jìn)行運(yùn)行算符重載//重載*T& operator*(){return *ptr;}//他只能在指針指向的是對(duì)象或者是結(jié)構(gòu)體的時(shí)候來使用T& operator->(){return ptr;}//某些情況下使用原生態(tài)指針T* get(){return ptr;} private:T* ptr;//采用類進(jìn)行指針管理 }; int main(){Smartptr<int> st1(new int);Smartptr<int> at2(st1);//此時(shí)調(diào)用拷貝構(gòu)造函數(shù)，但是這個(gè)類里面沒有，因此只能使用默認(rèn)的拷貝構(gòu)造//因此是淺拷貝return 0; }根據(jù)上面代碼，我們先簡單的模擬了一下智能指針發(fā)現(xiàn)了存在這一個(gè)致命的問題，如果當(dāng)一個(gè)對(duì)象對(duì)另一個(gè)對(duì)象進(jìn)行拷貝構(gòu)造時(shí)，由于沒有定義拷貝構(gòu)造函數(shù)，那么就會(huì)使用到默認(rèn)的拷貝構(gòu)造函數(shù)，產(chǎn)生淺拷貝問題。又因?yàn)樗械闹悄苤羔樁际且粯拥?#xff0c;那如何解決淺拷貝問題呢？我們?cè)谇懊鎸W(xué)習(xí)string類時(shí)，對(duì)淺拷貝的解決方式時(shí)使用深拷貝，但是在這里我們不能使用深拷貝，在string類中，因?yàn)槠鋬?nèi)部要存字符串，需要申請(qǐng)空間，而string類中的空間是自己申請(qǐng)與維護(hù)的，而智能指針的資源是用戶提供的，如下圖：
?智能指針不能申請(qǐng)資源只能提用戶來管理資源，因此此處不能使用深拷貝的方式來解決問題。
?1.2auto_ptr
?資源完全轉(zhuǎn)移
我們參考C++98版本的庫中就提供了auto_ptr的智能指針是如何解決淺拷貝問題的。
namespace bite{template<class T>class auto_ptr{public:// RAII : 保證資源可以自動(dòng)釋放auto_ptr(T* ptr = nullptr): _ptr(ptr){}~auto_ptr(){if (_ptr){delete _ptr;_ptr = nullptr;}}// 解決淺拷貝方式：資源轉(zhuǎn)移// auto_ptr<int> ap2(ap1)auto_ptr(auto_ptr<T>& ap): _ptr(ap._ptr){ap._ptr = nullptr;}// ap1 = ap2;auto_ptr<T>& operator=(auto_ptr<T>& ap){if (this != &ap){// 此處需要將ap中的資源轉(zhuǎn)移給this// 但是不能直接轉(zhuǎn)移，因?yàn)閠his可能已經(jīng)管理資源了，否則就會(huì)造成資源泄漏if (_ptr){delete _ptr;}// ap就可以將其資源轉(zhuǎn)移給this_ptr = ap._ptr;ap._ptr = nullptr; // 讓ap與之前管理的資源斷開聯(lián)系，因?yàn)閍p中的資源已經(jīng)轉(zhuǎn)移給this了}return *this;}// 對(duì)象具有指針類似的行為T& operator*(){return *_ptr;}T* operator->(){return _ptr;}T* Get(){return _ptr;}private:T* _ptr;}; } int main(){auto_ptr<int> st1(new int);auto_ptr<int> at2(st1);return 0; }我們觀察上述代碼，雖然他解決了淺拷貝問題，但是他又引入了新的問題,。當(dāng)對(duì)象拷貝或者賦值后，前面的對(duì)象就懸空了。它的缺陷就是當(dāng)我們想訪問或者修改st1對(duì)象的時(shí)候，代碼會(huì)崩潰。
資源管理權(quán)限轉(zhuǎn)移
?為了解決上面的問題有使用了轉(zhuǎn)移資源管理權(quán)限的思想。
#include<iostream> using namespace std; //智能指針的原理：RAII+具有指針類似的行為 //我們?cè)谶@里自己進(jìn)行封裝 template<class T> class autoptr{ public:autoptr(T* p = nullptr) :ptr(p), owner(true){}~autoptr(){if (ptr && owner){//此時(shí)指針如果不為空且具有釋放的權(quán)利的時(shí)候，則將其釋放，且將owner重新職位falsedelete ptr;owner = false;}}//在使用指針是我們有*與->的使用，因此在這里要對(duì)齊進(jìn)行運(yùn)行算符重載//重載*T& operator*(){return *ptr;}//他只能在指針指向的是對(duì)象或者是結(jié)構(gòu)體的時(shí)候來使用T& operator->(){return ptr;}//某些情況下使用原生態(tài)指針T* get(){return ptr;}//因此在這里解決淺拷貝問題//資源管理權(quán)限的轉(zhuǎn)移autoptr(autoptr<T>& p) :ptr(p.ptr), owner(p.owner){p.owner = false;}T& operator=(autoptr<T>& p){//賦值運(yùn)算符的重載if (this == p){//首先判斷是否是自己給自己復(fù)制return p;}if (ptr && owner){//如果此時(shí)ptr不為空且具有權(quán)限，那么此時(shí)就將現(xiàn)在的資源釋放掉，順便拿到p的權(quán)限delete ptr;ptr = p.ptr;owner = p.owner;p.owner = false;}}//某些情況下使用原生態(tài)指針 private:T* ptr;//采用類進(jìn)行指針管理 }; int main(){autoptr<int> st1(new int);autoptr<int> at2(st1);//此時(shí)調(diào)用拷貝構(gòu)造函數(shù)，但是這個(gè)類里面沒有，因此只能使用默認(rèn)的拷貝構(gòu)造函數(shù)//因此是淺拷貝return 0; }?如上面代碼，當(dāng)發(fā)生拷貝構(gòu)造或者賦值時(shí)，將被拷貝對(duì)象中資源轉(zhuǎn)移給新對(duì)象，然后讓被拷貝對(duì)象與資源斷開聯(lián)系，這樣就解決了一塊空間被多個(gè)對(duì)象使用而造成程序崩潰問題。但是在這里存在著致命缺陷。再對(duì)st1進(jìn)行拷貝后將其的指針賦值為空，導(dǎo)致了st1對(duì)象懸空，通過st1對(duì)象訪問資源就會(huì)出現(xiàn)問題，會(huì)造成野指針，使代碼崩潰。因此要在這里說明什么情況下對(duì)不要使用auto_ptr。
1.3unique_ptr
?上面的問題都是因?yàn)榘l(fā)生了拷貝構(gòu)造然后造成的，因此unique_ptr在這里采用的方式是禁止拷貝。也就是說，一份資源只能被一個(gè)對(duì)象來進(jìn)行管理，對(duì)象之見不能共享資源(資源獨(dú)占)。解決淺拷貝方式--資源獨(dú)占,防止拷貝，在這里有兩種方案，第一種：C++98中的方案，將拷貝構(gòu)造函數(shù)以及賦值運(yùn)算符重載方法只進(jìn)行聲明不進(jìn)行定義，并且將其權(quán)限給成私有的，這樣就防止其被拷貝。第二種：C++11種的方案：可以讓編譯器不生成默認(rèn)的拷貝構(gòu)造以及賦值運(yùn)算符delete，delete關(guān)鍵字它的擴(kuò)展功能就是從堆上進(jìn)行釋放資源，用其修飾默認(rèn)的構(gòu)造函數(shù)，表明編譯器不會(huì)生成了。
#include<iostream> using namespace std; //智能指針的原理：RAII+具有指針類似的行為 //我們?cè)谶@里自己進(jìn)行封裝 template<calss T> class DF_new{ public:void operatr()(T*& ptr){if(ptr){delete ptr;ptr = nullptr;}} }; template<calss T> class DF_free{ public:void operatr()(T*& ptr){if(ptr){free(ptr);ptr = nullptr;}} }; //關(guān)閉文件指針 template<calss T> class DF_close{ public:void operatr()(FILE*& ptr){if(ptr){fclose(ptr);ptr = nullptr;}} }; //T:資源中所放的數(shù)據(jù)的類型 //DF:資源的釋放方式 template<class T,class DF = DF_new<T>>//DF釋放的方式 class uniqueptr{ public:uniqueptr(T* p = nullptr) :ptr(p){}~uniqueptr(){if (ptr){//對(duì)于ptr管理的資源，有可能是從堆上申請(qǐng)的內(nèi)存空間，文件指針，malloc空間...//因此他在釋放的是否是要進(jìn)行考慮的，是不同的，解決的方式就是對(duì)這個(gè)類再加上一個(gè)模板參數(shù)列表即可ptr = nullptr;}}//在使用指針是我們有*與->的使用，因此在這里要對(duì)齊進(jìn)行運(yùn)行算符重載//重載*T& operator*(){return *ptr;}//他只能在指針指向的是對(duì)象或者是結(jié)構(gòu)體的時(shí)候來使用T& operator->(){return ptr;}//某些情況下使用原生態(tài)指針T* get(){return ptr;}//解決淺拷貝方式--資源獨(dú)占,防止拷貝，在這里有兩種方案//第一種：C++98中的方案： private:uniqueptr(const uniqueptr<T，DF>&);uniqueptr<T&>operator=(const uniqueptr<T,DF>&);//第二種：C++11中的方案：可以讓編譯器不生成默認(rèn)的拷貝構(gòu)造以及賦值運(yùn)算符--deleteuniqueptr(const uniqueptr<T,DF>&) = delete;//表明編譯器不會(huì)生成默認(rèn)的賦值運(yùn)算符重載uniqueptr<T,DF>& operator=(const uniqueptr<T,DF>&) = delete; private:T* ptr;//采用類進(jìn)行指針管理 };在這里說明一下為什么在C++98中對(duì)其拷貝構(gòu)造函數(shù)與賦值運(yùn)算符重載只進(jìn)行定義，不聲明不定義，且將其權(quán)限給成私有的。如果沒有將其設(shè)置為私有的，那么用戶就會(huì)在外部對(duì)其方法進(jìn)行定義。
unique_ptr指針適用于資源被一個(gè)對(duì)象管理并且不會(huì)被共享。他的缺陷就是多個(gè)對(duì)象中資源無法進(jìn)行共享，因此使用到了shared_ptr指針。
1.4shared_ptr
共享指針，對(duì)個(gè)對(duì)象之間可以共享資源。在這里采用引用計(jì)數(shù)的方式來進(jìn)行淺拷貝的。引用計(jì)數(shù)實(shí)際上就是一個(gè)整形空間，記錄使用資源的對(duì)象的個(gè)數(shù)，在釋放之前，讓最后一個(gè)使用資源的的對(duì)象來進(jìn)行釋放。
#include<iostream> using namespace std; //智能指針的原理：RAII+具有指針類似的行為 //我們?cè)谶@里自己進(jìn)行封裝 template<class T,class DF = DF_new<T>> class sharedptr{ public:sharedptr(T* p = nullptr) :ptr(p),p_count(nullptr){if(ptr){//此時(shí)只有當(dāng)前建好的一個(gè)對(duì)象在使用該份資源p_count = new int(1);}}~sharedptr(){if (ptr && 0 == --(*count)){DF df;df(ptr);delete p_count;p_count = nullptr;}}//在使用指針是我們有*與->的使用，因此在這里要對(duì)齊進(jìn)行運(yùn)行算符重載//重載*T& operator*(){return *ptr;}//他只能在指針指向的是對(duì)象或者是結(jié)構(gòu)體的時(shí)候來使用T& operator->(){return ptr;}//某些情況下使用原生態(tài)指針T* get(){return ptr;}//用戶可能需要獲取引用計(jì)數(shù)int use_count()const{return *p_count;}//解決淺拷貝方式，引用計(jì)數(shù)sharedptr(const sharedptr<T,DF>& sp):ptr(sp.ptr),p_count(sp.p_count){if(ptr){++(*p_count);}}sharedptr<T,DF>& operator=(const sharedptr<T,DF>& sp){if(this != &sp){//在sp共享之前，需要將之前的資源進(jìn)行釋放if(ptr && 0 == --*(p_count)){//如果此時(shí)之前的內(nèi)容只有他一個(gè)進(jìn)行管理，那么直接進(jìn)行釋放DF df;df(ptr);delete p_count;}//this就可以與sp進(jìn)行共享了ptr = sp->ptr;p_count = sp->p_count;if(p_count){p_count++;}}return *this;}private:T* ptr;//采用類進(jìn)行指針管理int* p_count;//指向的是使用資源的對(duì)象的個(gè)數(shù) };釋放的操作：先檢測是否有資源，有資源即是pcount>=1,先給計(jì)數(shù)器進(jìn)行-1操作，然后檢測計(jì)數(shù)器是否為0，如果是0，則說明當(dāng)前對(duì)象是最后使用資源的對(duì)象，，需要將資源以及計(jì)數(shù)空間進(jìn)行釋放，當(dāng)為非0的時(shí)候，說明還有其他對(duì)象在使用資源，當(dāng)前資源不需要釋放。
我們觀察上面的代碼，可以判斷吹他在單線程下是沒有出現(xiàn)問題的，但是在多線程下可能是有問題的。多線程下有多個(gè)執(zhí)行流，CPU也是多核的，多個(gè)線程同時(shí)往下執(zhí)行，假設(shè)現(xiàn)在連個(gè)線程中的智能指針共享的是同一份資源，兩個(gè)線程結(jié)束時(shí)，需要將其管理的資源釋放掉。也有情況下，線程同事進(jìn)行判斷，使得最后導(dǎo)致資源沒有進(jìn)行釋放，而引起資源泄漏。因此，在遇到共享的資源，變量等等之類的，需要考慮多線程環(huán)境下的安全性。因此最常見的方式是對(duì)其進(jìn)行加鎖。在這里進(jìn)行加鎖，是為了保證自身的安全性。
#include<iostream> using namespace std; //智能指針的原理：RAII+具有指針類似的行為 //我們?cè)谶@里自己進(jìn)行封裝 template<class T,class DF = DF_new<T>> class sharedptr{ public:sharedptr(T* p = nullptr) :ptr(p),p_count(nullptr),mutex(new mutex){if(_ptr){p_count = new int(1);}}~sharedptr(){reldef();}//在使用指針是我們有*與->的使用，因此在這里要對(duì)齊進(jìn)行運(yùn)行算符重載//重載*T& operator*(){return *ptr;}//他只能在指針指向的是對(duì)象或者是結(jié)構(gòu)體的時(shí)候來使用T& operator->(){return ptr;}//某些情況下使用原生態(tài)指針T* get(){return ptr;}//用戶可能需要獲取引用計(jì)數(shù)int use_count()const{return *p_count;}//解決淺拷貝方式，引用計(jì)數(shù)sharedptr(const sharedptr<T,DF>& sp):ptr(sp.ptr),p_count(sp.p_count),_pmutex(sp._pmutex){Addref();}sharedptr<T,DF>& operator=(const sharedptr<T,DF>& sp){if(this != &sp){//在sp共享之前，需要將之前的資源進(jìn)行釋放reldef();//this就可以與sp進(jìn)行共享了ptr = sp->ptr;p_count = sp->p_count;_pmutex = sp._pmutex;Addref();}return *this;} private:void Addref(){//對(duì)加法進(jìn)行處理if(!ptr) return;_pmutex->lock();++(*p_count);_pmutex->unlock();}//此時(shí)我們還需要判斷鎖是否需要釋放void reldef(){//對(duì)減法進(jìn)行處理if(ptr) return; bool isdelete = false;_pmutex->lock();if (ptr && 0 == --(*count)){DF df;df(ptr);delete p_count;p_count = nullptr;//當(dāng)資源釋放完畢后，對(duì)其進(jìn)行標(biāo)記isdelete = true;}_pmutex->unlock();if(isdelete){delete(_pmutex);}} private:T* ptr;//采用類進(jìn)行指針管理int* p_count;//指向的是使用資源的對(duì)象的個(gè)數(shù)mutex* _pmutex;//加上鎖的原因是要保證在這里引用計(jì)數(shù)的操作是原子性的 };雖然shared_ptr在這里是可以避免拷貝構(gòu)造帶來的錯(cuò)誤，但是他自身也有缺陷。在使用shared_ptr時(shí)可能會(huì)引起循環(huán)引用。什么是循環(huán)引用呢？我們先舉個(gè)例子。
#incldue<memory> struct ListNode{shared_ptr<ListNode*> next;shared_ptr<ListNode*> prve;int data;shared(int x):next(nullptr),prev(nullptr),data(x){cout<<"ListNode(int)"<<this<<endl;}~ListNode(){cout<<"~ListNode():"<<this<<endl;} }; void Looptest(){//將兩個(gè)節(jié)點(diǎn)分別交給智能指針來管理shared_ptr<ListNode> sp1(new ListNode(10));shared_ptr<ListNode> sp2(new ListNode(20));cout<<sp1.use_count()<<endl;cout<<sp2.use_count()<<endl;sp1->next = sp2;sp2->prev = sp1;cout<<sp1.use_count()<<endl;cout<<sp2.use_count()<<endl; } int main(){Looptest(); }當(dāng)shared_ptr管理的資源在相互指向的時(shí)候，我們看上面代碼的運(yùn)行情況：在結(jié)果中，我們發(fā)現(xiàn)運(yùn)行時(shí)并未出現(xiàn)調(diào)用析構(gòu)函數(shù)的結(jié)果，在這里沒有釋放掉資源，因此會(huì)引起資源泄露問題。也就是說，循環(huán)引用是指兩個(gè)對(duì)象之間形成了環(huán)路，在智能指針shared_ptr中存在這個(gè)問題，他的引用計(jì)數(shù)不為0。也就是兩份資源分別等待對(duì)方先進(jìn)行釋放，最后導(dǎo)致了內(nèi)存泄漏。處理這種現(xiàn)象十分簡單，只需要只使用一個(gè)weak_ptr即可。
1.5weak_ptr
weak_ptr的實(shí)現(xiàn)原理是使用了引用計(jì)數(shù)進(jìn)行實(shí)現(xiàn)的，他不可以進(jìn)行資源的管理，唯一的作用就是配合shared_ptr解決循環(huán)引用的問題。
#incldue<memory> struct ListNode{weak_ptr<ListNode*> next;weak_ptr<ListNode*> prve;int data;shared(int x):next(nullptr),prev(nullptr),data(x){cout<<"ListNode(int)"<<this<<endl;}~ListNode(){cout<<"~ListNode():"<<this<<endl;} }; void Looptest(){//將兩個(gè)節(jié)點(diǎn)分別交給智能指針來管理shared_ptr<ListNode> sp1(new ListNode(10));shared_ptr<ListNode> sp2(new ListNode(20));cout<<sp1.use_count()<<endl;cout<<sp2.use_count()<<endl;sp1->next = sp2;sp2->prev = sp1;cout<<sp1.use_count()<<endl;cout<<sp2.use_count()<<endl; } int main(){Looptest(); }
我們看上面的代碼，此時(shí)析構(gòu)函數(shù)執(zhí)行了，并沒有發(fā)生引用循環(huán)。
question：為什么weak_ptr可以解決循環(huán)引用？
原因是在他的引用計(jì)數(shù)上。如上圖代碼，我們進(jìn)行分析：
?在標(biāo)準(zhǔn)庫中，weak_ptr的引用計(jì)數(shù)維護(hù)了兩份，由圖可知，當(dāng)開始執(zhí)行時(shí)，use=weak=1;此時(shí)在執(zhí)行sp1->next=sp2，因?yàn)閟p1->next的類型是一個(gè)weak_ptr,因此此時(shí)的sp2的引用計(jì)數(shù)的weak++，再執(zhí)行sp2->prve=sp1，因?yàn)閟p2->prve的類型也是一個(gè)weak_ptr，因此此時(shí)的sp1的引用計(jì)數(shù)weak++；此時(shí)sp1指向空間中的計(jì)數(shù)use=1，weak=2，sp2指向的資源空間的計(jì)數(shù)也是一樣。
現(xiàn)在要對(duì)資源進(jìn)行釋放。首先釋放sp2，因?yàn)閟p2的類型是一個(gè)shared_ptr，use--等于0，說明此時(shí)資源是可以進(jìn)行釋放的，因此就要對(duì)對(duì)象內(nèi)部的每一個(gè)資源進(jìn)行釋放掉，sp2->prev是weak_ptr類型，將其銷毀，那么左面資源的中的引用計(jì)數(shù)weak--，然后sp2->prve與sp1斷開，next指針也銷毀掉了，因此此時(shí)的節(jié)點(diǎn)也銷毀掉了，所以sp2的pcount與資源的引用計(jì)數(shù)斷開，右面的資源的引用計(jì)數(shù)weak--。
現(xiàn)在進(jìn)行釋放sp1，因?yàn)閟p1的類型是一個(gè)shared_ptr，use--等于0，說明此時(shí)資源是可以進(jìn)行釋放的，因此就要對(duì)對(duì)象內(nèi)部的每一個(gè)資源進(jìn)行釋放掉，sp1->next是weak_ptr類型，將其銷毀，那么右面資源的中的引用計(jì)數(shù)weak--，此時(shí)右面的引用計(jì)數(shù)的weak=0，因此就可以將右面資源的引用計(jì)數(shù)進(jìn)行釋放；左面資源的prve指針此時(shí)也銷毀了，此時(shí)節(jié)點(diǎn)進(jìn)行銷毀，所以sp1的pcount與資源的引用計(jì)數(shù)斷開，左面的weak--等于0，此時(shí)將左面的資源的引用計(jì)數(shù)進(jìn)行銷毀。
總結(jié)：當(dāng)一個(gè)資源被shared_ptr共享時(shí)，use++;當(dāng)一個(gè)資源被weak_ptr共享時(shí)，weak++。且只有shared_ptr可以獨(dú)立的管理資源。
question:unique_ptr與shared_ptr能否可以管理一塊連續(xù)空間？
可以。如果要管理里一段連續(xù)的空間，我們必須自己實(shí)現(xiàn)刪除器，operator()(T*&ptr){delete[] ptr;ptr=nullptr;}。但是沒有什么意義，對(duì)于連續(xù)空間，一般是不會(huì)直接交給智能指針進(jìn)行管理的，因?yàn)樵赟TL中已經(jīng)有了vector。
總結(jié)
- 上一篇： 软件工程期末总复习
- 下一篇： s3c2440移植MQTT