2. 程式人生 > >C++中智慧指標的設計和使用

C++中智慧指標的設計和使用

阿新 • • 發佈：2019-01-05
原文地址：http://blog.csdn.net/hackbuteer1/article/details/7561235
     智慧指標(smart pointer)是儲存指向動態分配（堆）物件指標的類，用於生存期控制，能夠確保自動正確的銷燬動態分配的物件，防止記憶體洩露。它的一種通用實現技術是使用引用計數(reference count)。智慧指標類將一個計數器與類指向的物件相關聯，引用計數跟蹤該類有多少個物件共享同一指標。每次建立類的新物件時，初始化指標並將引用計數置為1；當物件作為另一物件的副本而建立時，拷貝建構函式拷貝指標並增加與之相應的引用計數；對一個物件進行賦值時，賦值操作符減少左運算元所指物件的引用計數（如果引用計數為減至0，則刪除物件），並增加右運算元所指物件的引用計數
；呼叫解構函式時，建構函式減少引用計數（如果引用計數減至0，則刪除基礎物件）。
    智慧指標就是模擬指標動作的類。所有的智慧指標都會過載 -> 和 * 操作符。智慧指標還有許多其他功能，比較有用的是自動銷燬。這主要是利用棧物件的有限作用域以及臨時物件（有限作用域實現）解構函式釋放記憶體。當然，智慧指標還不止這些，還包括複製時可以修改源物件等。智慧指標根據需求不同，設計也不同（寫時複製，賦值即釋放物件擁有許可權、引用計數等，控制權轉移等）。auto_ptr 即是一種常見的智慧指標。
     智慧指標通常用類模板實現：
  1. template <class T>  
  2. class smartpointer  
  3. {  
  4. private:  
  5.     T *_ptr;  
  6. public:  
  7.     smartpointer(T *p) : _ptr(p)  //建構函式
  8.     {  
  9.     }  
  10.     T& operator *()        //過載*操作符
  11.     {  
  12.         return *_ptr;  
  13.     }  
  14.     T* operator ->()       //過載->操作符
  15.     {  
  16.         return _ptr;  
  17.     }  
  18.     ~smartpointer()        //解構函式
  19.     {  
  20.         delete _ptr;  
  21.     }  
  22. };  
實現引用計數有兩種經典策略，在這裡將使用其中一種，這裡所用的方法中，需要定義一個單獨的具體類用以封裝引用計數和相關指標：
  1. // 定義僅由HasPtr類使用的U_Ptr類，用於封裝使用計數和相關指標
  2. // 這個類的所有成員都是private，我們不希望普通使用者使用U_Ptr類，所以它沒有任何public成員
  3. // 將HasPtr類設定為友元，使其成員可以訪問U_Ptr的成員
  4. class U_Ptr  
  5. {  
  6.     friendclass HasPtr;  
  7.     int *ip;  
  8.     size_t use;  
  9.     U_Ptr(int *p) : ip(p) , use(1)  
  10.     {  
  11.         cout << "U_ptr constructor called !" << endl;  
  12.     }  
  13.     ~U_Ptr()  
  14.     {  
  15.         delete ip;  
  16.         cout << "U_ptr distructor called !" << endl;  
  17.     }  
  18. };  
       HasPtr類需要一個解構函式來刪除指標。但是，解構函式不能無條件的刪除指標。”
      條件就是引用計數。如果該物件被兩個指標所指，那麼刪除其中一個指標，並不會呼叫該指標的解構函式，因為此時還有另外一個指標指向該物件。看來，智慧指標主要是預防不當的析構行為，防止出現懸垂指標。

     如上圖所示，HasPtr就是智慧指標，U_Ptr為計數器；裡面有個變數use和指標ip，use記錄了*ip物件被多少個HasPtr物件所指。假設現在又兩個HasPtr物件p1、p2指向了U_Ptr，那麼現在我delete  p1，use變數將自減1，  U_Ptr不會析構，那麼U_Ptr指向的物件也不會析構，那麼p2仍然指向了原來的物件，而不會變成一個懸空指標。當delete p2的時候，use變數將自減1，為0。此時，U_Ptr物件進行析構，那麼U_Ptr指向的物件也進行析構，保證不會出現記憶體洩露。 
    包含指標的類需要特別注意複製控制，原因是複製指標時只複製指標中的地址，而不會複製指標指向的物件。
    大多數C++類用三種方法之一管理指標成員
    （1）不管指標成員。複製時只複製指標，不復制指標指向的物件。當其中一個指標把其指向的物件的空間釋放後，其它指標都成了懸浮指標。這是一種極端
    （2）當複製的時候，即複製指標，也複製指標指向的物件。這樣可能造成空間的浪費。因為指標指向的物件的複製不一定是必要的。
   （3） 第三種就是一種折中的方式。利用一個輔助類來管理指標的複製。原來的類中有一個指標指向輔助類，輔助類的資料成員是一個計數器和一個指標（指向原來的）（此為本次智慧指標實現方式）。
     其實，智慧指標的引用計數類似於java的垃圾回收機制：java的垃圾的判定很簡答，如果一個物件沒有引用所指，那麼該物件為垃圾。系統就可以回收了。
     HasPtr 智慧指標的宣告如下，儲存一個指向U_Ptr物件的指標，U_Ptr物件指向實際的int基礎物件，程式碼如下：
  1. #include<iostream>
  2. usingnamespace std;  
  3. // 定義僅由HasPtr類使用的U_Ptr類，用於封裝使用計數和相關指標
  4. // 這個類的所有成員都是private，我們不希望普通使用者使用U_Ptr類，所以它沒有任何public成員
  5. // 將HasPtr類設定為友元，使其成員可以訪問U_Ptr的成員
  6. class U_Ptr  
  7. {  
  8.     friendclass HasPtr;  
  9.     int *ip;  
  10.     size_t use;  
  11.     U_Ptr(int *p) : ip(p) , use(1)  
  12.     {  
  13.         cout << "U_ptr constructor called !" << endl;  
  14.     }  
  15.     ~U_Ptr()  
  16.     {  
  17.         delete ip;  
  18.         cout << "U_ptr distructor called !" << endl;  
  19.     }  
  20. };  
  21. class HasPtr  
  22. {  
  23. public:  
  24.     // 建構函式：p是指向已經動態建立的int物件指標
  25.     HasPtr(int *p, int i) : ptr(new U_Ptr(p)) , val(i)  
  26.     {  
  27.         cout << "HasPtr constructor called ! " << "use = " << ptr->use << endl;  
  28.     }  
  29.     // 複製建構函式：複製成員並將使用計數加1
  30.     HasPtr(const HasPtr& orig) : ptr(orig.ptr) , val(orig.val)  
  31.     {  
  32.         ++ptr->use;  
  33.         cout << "HasPtr copy constructor called ! " << "use = " << ptr->use << endl;  
  34.     }  
  35.     // 賦值操作符
  36.     HasPtr& operator=(const HasPtr&);  
  37.     // 解構函式：如果計數為0，則刪除U_Ptr物件
  38.     ~HasPtr()  
  39.     {  
  40.         cout << "HasPtr distructor called ! " << "use = " << ptr->use << endl;  
  41.         if (--ptr->use == 0)  
  42.             delete ptr;  
  43.     }  
  44.     // 獲取資料成員
  45.     int *get_ptr() const
  46.     {  
  47.         return ptr->ip;  
  48.     }  
  49.     int get_int() const
  50.     {  
  51.         return val;  
  52.     }  
  53.     // 修改資料成員
  54.     void set_ptr(int *p) const
  55.     {  
  56.         ptr->ip = p;  
  57.     }  
  58.     void set_int(int i)  
  59.     {  
  60.         val = i;  
  61.     }  
  62.     // 返回或修改基礎int物件
  63.     int get_ptr_val() const
  64.     {  
  65.         return *ptr->ip;  
  66.     }  
  67.     void set_ptr_val(int i)  
  68.     {  
  69.         *ptr->ip = i;  
  70.     }  
  71. private:  
  72.     U_Ptr *ptr;   //指向使用計數類U_Ptr
  73.     int val;  
  74. };  
  75. HasPtr& HasPtr::operator = (const HasPtr &rhs)  //注意，這裡賦值操作符在減少做運算元的使用計數之前使rhs的使用技術加1，從而防止自我賦值
  76. {  
  77.     // 增加右運算元中的使用計數
  78.     ++rhs.ptr->use;  
  79.     // 將左運算元物件的使用計數減1，若該物件的使用計數減至0，則刪除該物件
  80.     if (--ptr->use == 0)  
  81.         delete ptr;  
  82.     ptr = rhs.ptr;   // 複製U_Ptr指標
  83.     val = rhs.val;   // 複製int成員
  84.     return *this;  
  85. }  
  86. int main(void)  
  87. {  
  88.     int *pi = newint(42);  
  89.     HasPtr *hpa = new HasPtr(pi, 100);    // 建構函式
  90.     HasPtr *hpb = new HasPtr(*hpa);     // 拷貝建構函式
  91.     HasPtr *hpc = new HasPtr(*hpb);     // 拷貝建構函式
  92.     HasPtr hpd = *hpa;     // 拷貝建構函式
  93.     cout << hpa->get_ptr_val() << " " << hpb->get_ptr_val() << endl;  
  94.     hpc->set_ptr_val(10000);  
  95.     cout << hpa->get_ptr_val() << " " << hpb->get_ptr_val() << endl;  
  96.     hpd.set_ptr_val(10);  
  97.     cout << hpa->get_ptr_val() << " " << hpb->get_ptr_val() << endl;  
  98.     delete hpa;  
  99.     delete hpb;  
  100.     delete hpc;  
  101.     cout << hpd.get_ptr_val() << endl;  
  102.     return 0;  
  103. }  
這裡的賦值操作符比較麻煩，且讓我用圖表分析一番：
假設現在又兩個智慧指標p1、 p2，一個指向內容為42的記憶體，一個指向內容為100的記憶體，如下圖：

現在，我要做賦值操作，p2 = p1。對比著上面的
  1. HasPtr& operator=(const HasPtr&);   // 賦值操作符
此時，rhs就是p1，首先將p1指向的ptr的use加1，
  1. ++rhs.ptr->use;     // 增加右運算元中的使用計數
然後，做：
  1. if (--ptr->use == 0)  
  2.         delete ptr;  
因為，原先p2指向的物件現在p2不在指向，那麼該物件就少了一個指標去指，所以，use做自減1；
此時，條件成立。因為u2的use為1。那麼，執行U_Ptr的解構函式，而在U_Ptr的解構函式中，做了delete ip操作，所以釋放了記憶體，不會有記憶體洩露的問題。
接下來的操作很自然，無需多言：
  1. ptr = rhs.ptr;   // 複製U_Ptr指標
  2.     val = rhs.val;   // 複製int成員
  3.     return *this;  
做完賦值操作後，那麼就成為如下圖所示了。紅色標註的就是變化的部分：

而還要注意的是，過載賦值操作符的時候，一定要注意的是，檢查自我賦值的情況。
如圖所示：

此時，做p1 = p1的操作。那麼，首先u1.use自增1，為2；然後，u1.use自減1，為1。那麼就不會執行delete操作，剩下的操作都可以順利進行。按《C++ primer》說法，“這個賦值操作符在減少左運算元的使用計數之前使rhs的使用計數加1，從而防止自身賦值”。哎，反正我是那樣理解的。當然，賦值操作符函式中一來就可以按常規那樣：
  1. if(this == &rhs)  
  2.         return *this;  
執行結果如下圖：

相關推薦

C++中智慧指標的設計和使用

原文地址：http://blog.csdn.net/hackbuteer1/article/details/7561235      智慧指標(smart pointer)是儲存指向動態分配（堆）物件指標的類，用於生存期控制，能夠確保自動正確的銷燬動態分配的物件，防止記憶體

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

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

C++之智慧指標和普通指標單例模式兩種實現

1  問題 實現c++的單例模式，這裡測試分別寫了通過智慧指標返回物件和普通返回指標     2  程式碼測試 include <iostream> #include <mutex> #include <m

C++11智慧指標和引用

最近在學習課程的時候發現一個很困惑的問題，上程式碼 class DataHeader; class LoginResult:public DataHeader; typedef std::shared_ptr<DataHeader> DataHeaerPtr; //原型 void addS

c++ 之智慧指標：儘量使用std::make_unique和std::make_shared而不直接使用new

關於make_unique的構造及使用例程，MSDN的講解非常詳細 （https://msdn.microsoft.com/zh-cn/library/dn439780.aspx ） 使用過程中，主要有這麼幾個關鍵點： 1.  make_unique 同 uni

c++ 中的指標和引用

首先： 指標是儲存的變數的地址，引用是變數的別名，這個必須記住 單純的給變數取別名沒有任何的意義，作為引數傳遞，能保證引數傳遞過程中不產生任何的副本 引用可以直接操作變數，但指標的話必須通過（*p）間接的操作變數，指標可讀性行比較低 //引用必須要有初始值 //

c++中使用指標呼叫函式和使用指標呼叫類物件的（）過載函式

使用函式指標時，指標可以像函式名一樣，直接加括號和引數列表呼叫；也可先解引用再呼叫 //include directories... using namespace std; void testFun() { cout<<"this is

C++11中智慧指標的使用

1.C++11中新增了三種智慧指標，在初始化指標後，如果類被析構，那指標所指向的物件會被自動析構，方便了程式設計師對指標的控制。 share_ptr：共享的智慧指標 weak_ptr：配合share_ptr使用的弱指標 unique_ptr：獨佔的智慧指標 2.智

C語言中的指標陣列和陣列指標

可以將 *string看成陣列 a[] 下的a，即指標是指向陣列的首地址的； 指標陣列是陣列元素為指標的陣列(例如 int *p[3],定義了p[0],p[1],p[2]三個指標)，其本質為陣列。 指

C/C++中二維陣列和指標關係分析

        在C/c++中，陣列和指標有著密切的關係，有很多地方說陣列就是指標式錯誤的一種說法。這兩者是不同的資料結構。其實，在C/c++中沒有所謂的二維陣列，書面表達就是陣列的陣列。我猜想是為了表述方便才叫它二維陣列。       在本文中，我也就叫它二維陣列。在C/C

C++中this指標的理解和用法

關於this指標的一個精典回答: 當你進入一個房子後，你可以看見桌子、椅子、地板等，但是房子你是看不到全貌了。對於一個類的例項來說，你可以看到它的成員函式、成員變數，但是例項本身呢？this是一個指標，它時時刻刻指向你這個例項本身。 個人理解： （ps：class類就好比這

C語言呼叫jni中JNIEnv指標使用和理解

使用C語言呼叫jni的時候，需要和java的環境物件和虛擬機器物件互動。它們的C語言定義如下。typedef const struct JNINativeInterface* JNIEnv; typedef const struct JNIInvokeInterface* J

java中的引用和C++中的指標的區別

1.型別：引用其值為地址的資料元素，java封裝了的地址，可以轉成字串檢視，長度可以不必關心。C++指標是一個裝地址的變數,長度一般是計算機字長，可以認為是個int。 2.所佔記憶體： 引用宣告時沒有實體，不佔空間。C++指標如果聲明後會用到才會賦值，如果用不到不會分配記憶體

C++ 11 智慧指標的坑和引用計數的意義

一、本節內容本節內容包括：對標準庫的擴充: 智慧指標和引用計數RAII 與引用計數std::shared_ptrstd::unique_ptrstd::weak_ptr二、RAII 與引用計數瞭解 Objective-C/Swift 的程式設計師應該知道引用計數的概念。引用計

C++中int *p[4]和 int (*q)[4]的區別 （指標陣列和陣列指標)

int *p[4]; //定義一個指標陣列，該陣列中每個元素是一個指標，每個指標指向哪裡就需要程式中後續再定義了。int (*p)[4]; //定義一個數組指標，該指標指向含4個元素的一維陣列（陣列中每個元素是int型）。區分int *p[n]; 和int (*p)[n]; 就要看運算子的優先順序了。

C/C++中字元指標和字元陣列、字元指標陣列及指向指標的指標的含義

字元指標和字元陣列 char* s1="hello"; char  s2[]="world";兩個表示式的含義是一樣的.如果講不同之處的話,VC6中編譯時,對這兩種定義進行了不同的處理;char *s1 = "hello"; 中的"hello",編譯時指標指向的區域位於PE

C++類中的指標成員和拷貝建構函式

對C++程式設計師來說，編寫C++程式有一條必須注意的規則，就是類中包含了一個指標成員的話，那麼 就要小心拷貝建構函式的編寫， 因為一不小心，就會出現記憶體洩漏。 看下面的例子： #include <iostream> class HasPtrMem { pu

C++中常量指標和指標常量的區別

一、常量指標 常量指標本質是指標，常量修飾它，表示這個指標是一個指向常量的指標（變數），也就是指向一個無法修改的量。 C++中常量指標定義為：const int* a，當然int const * a也可以，不過習慣用第一種了。 使用常量指標時要注意，指標指向的物件不能通

C++中傳值引數和引用引數和指標怎樣區別？

C++中傳值引數和引用引數怎樣區別呢？ 看以下例子：#include<iostream>using namespace std;void swap(int a,int b){int temp;temp=a;a=b;b=temp;}main(){int a=3,b=

C#中簡單的繼承和多態

補充 是個 main ase ide 初始化 子類 public 泛型 今天我們來聊一聊繼承，說實話今天也是我第一次接觸。 繼承的概念是什麽呢？就是一個類可以繼承另一個類的屬性和方法（成員） 繼承是面向對象編程中的一個非常重要的特性。 好了，廢話不多說，下面切入正題：