C/C++學習之路: 智能指針

---

目錄

前言

shared_ptr

---

1. 前言

在C++中，動態內存的管理是通過一對運算符完成的：

new：在動態內存中為對象分配空間并返回一個指向該對象的指針，可以選擇對對象進行初始化

delete：接受一個動態對象的指針，銷毀該對象，并釋放與之關聯的內存

動態內存使用容易出現問題，因為很難保證在正確的時間釋放內存，如果忘記釋放內存就會產生內存泄漏，或者在有指針引用內存的情況下釋放就會產生引用非法內存的指針。

為了更方便也更安全使用動態內存，新的標準庫提供了兩種智能指針類型來管理動態對象。智能指針類似于常規指針，區別在于智能指針負責自動釋放所指向的對象。

新標準庫提供的這兩種智能指針區別在于管理低層指針的方式：

shared_ptr允許多個指針指向同一個對象。

unique_ptr則獨占所指向的對象。

標準庫還定義了weak_ptr的伴隨類，是一種弱引用，指向shared_ptr所管理的對象。

---

2. shared_ptr

類似于vector，智能指針也是模板，創建一個智能指針時，必須提供指針可以指向的類型。

shared_ptr<int> p1; shared_ptr<list<string>> p2;

默認智能指針保存一個空指針。

智能指針的使用方式和普通指針類似，解引用一個智能指針返回它指向的對象。如果在一個條件判斷中使用智能指針就是檢測它是否為空。

if (p1 && p1->empty()) {*p1 = "hi"; }

下標列出了shared_ptr和unique_ptr都支持的操作。

shared_ptr獨有的操作

1. make_shared函數

最安全的分配和使用動態內存的方法是調用一個名為make_shared的標準庫函數，會在動態內存中分配一個對象并初始化它，返回指向此對象的shared_ptr。

當用make_shared時，必須指定要創建的對象的類型。

//指向一個值為42的int的shared_ptr shared_ptr<int> p3 = make_shared<int>(42); //指向一個值為"999999999"的string shared_ptr<string> p4 = make_shared<string>(10, '9'); //指向一個值初始化的int，即值為0 shared_ptr<int> p5 = make_shared<int>();

make_shared用參數來構造給定類型的對象，如果不傳遞任何參數，對象就進行值初始化。

//p6指向一個動態分配的空vector<string> auto p6 = make_shared<vector<string>>();

2. shared_ptr的拷貝和賦值

當進行拷貝或賦值時，每個shared_ptr都會記錄有多少個其他shared_ptr指向相同的對象：

auto p = make_shared<int>(42); //p指向的對象只有p一個引用者auto q(p); //p和q指向相同對象，此對象有兩個引用者

每個shared_ptr都有一個引用計數器，無論拷貝哪個shared_ptr，計數器都會遞增。比如用一個shared_ptr初始化另一個shared_ptr，或者將它作為參數傳遞給一個函數以及作為函數的返回值時，所關聯的計數器都會遞增。

當給shared_ptr賦予一個新值或是shared_ptr被銷毀（例如一個局部的shared_ptr離開其作用域），計數器就會遞減。

一旦一個shared_ptr計數器為0，就會自動釋放自己所管理的對象。

auto r = make_shared<int>(42);r = q; //給r賦值，令它指向另一個地址// 遞增q指向的對象的引用計數，遞減r原來指向的對象的引用計數// r原來指向的對象已沒有引用者，會自動釋放

上例中分配了一個int，將其職責保存在r中，接下來將一個新的值賦予r，在此情況下，r是唯一指向此int的shared_ptr，在把q賦給r后，此int被自動釋放。

3. shared_ptr自動銷毀所管理的對象

當指向一個對象的最后一個shared_ptr被銷毀時，shared_ptr類會自動銷毀此對象。它是通過析構函數完成銷毀工作的。

析構函數一般用來釋放對象所分配的資源。例如string的構造函數會分配內存來保存構成string的字符。string的析構函數就負責釋放這些內存。

shared_ptr的析構函數會遞減它所指向的對象的引用計數，如果引用計數為0，shared_ptr的析構函數就會銷毀對象，并釋放它占用的內存。

4. shared_ptr還會自動釋放相關聯的內存

當動態對象不再使用時，shared_ptr類會自動釋放動態對象，這一特性使得動態內存的使用變得非常容易。

例如有一個函數，返回一個shared_ptr，指向一個Foo類型的動態分配的對象，對象是通過一個類型為T的參數進行初始化的：

shared_ptr<Foo> factory(T arg) {//恰當處理arg//shared_ptr負責釋放內存return make_shared<Foo>(arg); }

由于factory返回一個shared_ptr，所以可以確保它分配的對象會在恰當的時刻被釋放。例如，下面的函數將factory返回的shared_ptr保存在局部變量中：

void use_factory(T arg) {shared_ptr<Foo> p = factory(arg);//使用p，p離開作用域，它指向的內存會被自動釋放掉 }

由于p是use_factory的局部變量，在use_factory結束時它將被銷毀，當p被銷毀時，將遞減其引用計數并檢查它是否為0，例子中，p是唯一引用factory返回的內存的對象。由于p將要銷毀，p指向的這個對象也會被銷毀，所占用的內存會釋放。

但如果有其他shared_ptr也指向這塊內存，它就不會被釋放。

對于一塊內存，shared_ptr類保證只要有任何shared_ptr對象引用它，它就不會被釋放掉。

由于最后一個shared_ptr銷毀前內存都不會被釋放，保證shared_ptr在無用之后不再保留就很重要了。

如果忘記銷毀程序不再需要的shared_ptr，程序仍會正常執行，但會浪費內存。

如果將shared_ptr存放于一個容器中，而后不再需要全部元素，而只使用其中一部分，要記得用erase刪除不再需要的那些元素。

5. 使用了動態生存期的資源的類

程序使用動態內存出于以下三種原因之一

程序不知道自己需要使用多少對象

程序不知道所需對象的準確類型

程序需要在多個對象間共享數據

容器類是出于第一種原因而使用動態內存的典型例子。下面將定義一個類，使用動態內存是為了讓多個對象能共享相同的底層數據。

在我們使用過的類中，分配的資源都與對應對象生存期一致。例如每個vector“擁有”自己的元素，當我們拷貝一個vector時，原vector和副本vector中的元素的相互分離的。

vector<string> v1; //空vector{vector<string> v2 = {"a", "an", "the"};v1 = v2; // 從v2拷貝元素到v1中} //v2被銷毀，其中的元素也被銷毀，v1有三個元素，是原來v2中元素的拷貝

由一個vector分配的元素只有當這個vector存在時才存在，當一個vector被銷毀時，這個vector中的元素也都被銷毀。

但某些類分配的資源具有與原來對象相獨立的生存期。例如，定義一個Blob的類，保存一組元素，Blob對象的不同拷貝之間共享相同的元素，即當拷貝一個Blob時，原Blob對象及其拷貝應該引用相同的低層元素。

一般而言，如果兩個對象共享底層的數據，當某個對象被銷毀時，不能單方面地銷毀底層數據：

Blob<string> b1; //空Blob{ //新作用域Blob<string> b2 = {"a", "an", "the"};b1 = b2; // b1和b2共享相同的元素} // b2被銷毀了，但b2中的元素不能銷毀，b1指向最初由b2創建的元素

b1和b2共享相同的元素，當b2離開作用域后，這些元素必須保留，因為b1仍然在使用它們。

使用動態內存的一個常見原因是允許多個對象共享相同的狀態。

6. 定義StrBlob類

定義一個管理string的類命名為StrBlob，實現一個新的集合類型最簡單方法是使用某個標準庫容器來管理元素，在本例中，將使用vector保存元素。

為了保證vector的元素繼續存在，將vector保存在動態內存中。為每個StrBlob設置一個shared_ptr來管理動態分配的vector。此shared_ptr的成員將記錄有多少個StrBlob共享相同的vector，并在vector的最后一個使用者被銷毀時釋放vector。

這個類提供的操作有修改訪問元素的操作（如front和back），如果用戶訪問不存在的元素，會拋出一個異常。

類有一個默認構造函數和一個析構函數，接受單一的initializer_list類型參數。此構造函數可以接受一個初始化器的花括號列表。

class StrBlob { public:typedef std::vector<std::string>::size_type size_type;StrBlob();StrBlob(std::initializer_list<std::string> il);size_type size() const { return data->size(); }bool empty() const { return data->empty(); }//添加和刪除元素void push_back(const std::string &t) { data->push_back(t); }void pop_back();//元素訪問std::string &front();std::string &back();private:std::shared_ptr<std::vector<std::string>> data;//如果data[i]不合法，拋出一個異常void check(size_type i, const std::string &msg) const;};

StrBlob類實現了size，empty和push_back成員。這些成員通過指向底層vector的data成員來完成工作。例如，對一個StrBlob對象調用size()會調用data->size()，以此類推。

7. StrBlob構造函數

兩個構造函數都使用初始化列表來初始化其data成員，令它指向一個動態分配的vector。默認構造函數分配了一個空vector。

StrBlob::StrBlob() : data(make_shared<vector<string>>()) {}StrBlob::StrBlob(std::initializer_list<std::string> il) : data(make_shared<vector<string>>(il)) {}

接受一個initializer_list的構造函數將其參數傳遞給對應的vector構造函數。此構造函數通過拷貝列表中的值來初始化vector的元素。

8. 元素訪問成員函數

pop_back、front和back操作訪問vector中的元素，這些操作試圖訪問元素之前必須檢查元素是否存在。

由于這些成員函數需要做相同的檢查操作，所以為StrBlob定義了一個名為check的private工具函數，它檢查一個給定索引是否在合法范圍內。

除了索引，check還接受一個string參數傳遞給異常處理程序，這個string描述了錯誤內容。

void StrBlob::check(StrBlob::size_type i, const std::string &msg) const {if (i >= data->size()) {throw out_of_range(msg);} }

pop_back和元素訪問成員函數首先調用check。如果check成功，這些成員函數繼續利用底層vector的操作來完成自己的工作。

std::string &StrBlob::front() {//如果vector為空，check會拋出一個異常check(0, "front ont empty StrBlob");return data->front(); }std::string &StrBlob::back() {check(0, "back ont empty StrBlob");return data->back(); }void StrBlob::pop_back() {check(0, "pop_back ont empty StrBlob");data->pop_back(); }

9. StrBlob的拷貝，賦值和銷毀

StrBlob使用默認版本的拷貝、賦值和銷毀成員函數來對此類型的對象進行操作。StrBlob類只有一個數據成員，它是shared_ptr類型，因此，當拷貝，賦值和銷毀一個StrBlob對象時，它的shared_ptr成員會被拷貝，賦值和銷毀。

拷貝一個shared_ptr會遞增其引用計數，將一個shared_ptr賦予另一個shared_ptr會遞增賦值號右側shared_ptr的引用計數，而遞減左側shared_ptr的引用計數。

如果一個shared_ptr的引用計數變為0，它所指向的對象會被自動銷毀，因此，對于StrBlob構造函數分配的vector，當最后一個指向它的StrBlob對象被銷毀時也會隨著銷毀。

---

2. 直接管理內存

C++定義了兩個運算符來分配和釋放動態內存。運算符new分配內存，delete釋放new分配的內存。

相對于智能指針，使用這兩個運算符管理內存非常容易出錯，直接管理內存的類與使用智能指針的類不同，不能依賴對象拷貝、賦值和銷毀操作的任何默認定義。

因此，使用智能指針的程序更容易編寫和調試。

1. 使用new動態分配和初始化對象

在自由空間分配的內存是無名的，因此new無法為其分配的對象命名，而是返回一個指向對象的指針：

int *p = new int; //p指向一個動態分配的、未初始化的無名對象

默認情況下，動態分配的對象是默認初始化的，意味著內置類型或組合類型的對象是指將是未定義的，而類的類型對象將用默認夠贊函數進行初始化。

string *ps = new string; //初始化為空string

可以使用直接初始化方式來初始化一個動態分配的對象。

int *pi = new int(1024); //pi指向的對象的值為1024 string *ps = new string(10,'9'); // *ps為‘9999999999’ //vector有10個元素，值依次從0到9 vector<int> *pv = new vector<int>{0,1,2,3,4,5,6,7,8,9};

也可以對動態分配的對象進行值初始化，只需要在類型名后跟一對空括號就行

string *ps1 = new string; //默認初始化為空string string *ps = new string(); //值初始化為空string int *pi1 = new int; //默認初始化，*pi1的值未定義 int *pi2 = new int(); //值初始化為0，*pi2為0

對于定義了自己的構造函數的類類型（例如string）來說，要求值初始化是沒有意義的。不管采用什么形式，對象都會通過默認構造函數來初始化。

但對于內置類型，兩種形式的差別就很大：值初始化的內置類型對象有定義的值，而默認初始化的對象的值是未定義的。

對于類中那些依賴編譯器合成的默認構造函數的內置類型成員，如果它們未在類中被初始化，那么值也是未定義的。

如果提供了一個括號包圍的初始化器，就可以使用auto從此初始化器來推斷想要分配的對象的類型。

但是，由于編譯器要用初始化器的類型來推斷要分配的類型，只有當括號中僅有單一初始化器材可以使用auto：

auto p1 = new auto(obj); //p指向一個與obj類型相同的對象，該對象用obj進行初始化 auto p2 = new auto{a,b,c}; // 錯誤：括號中只能有單個初始化器

p1的類型是一個指針，指向從obj自動推斷出的類型。如果obj是一個int，那么p1就是int *，如果obj是string，那么p1就是string *。

2. 動態分配的const對象

用new分配const對象是合法的

const int *pci = new const int(1024); //分配并初始化一個const int const string *pcs = new const string; //分配并默認初始化一個const的空string

一個動態分配的const對必須進行初始化，對于一個定義了默認構造函數的類類型，const動態對象可以隱式初始化，而其他類型的對象就必須顯式初始化。

由于分配的對象是const的，new返回的指針是一個指向const的指針。

3. 內存耗盡

一旦一個程序用光了它所有可用的內存，new表達式就會失敗。默認情況下，如果new不能分配所要求的內存空間，就會拋出一個類型為bad_alloc的異常，我們可以改變使用new的方式來阻止它拋出異常。

//如果分配失敗，new返回一個空指針 int *p1 = new int; // 如果分配失敗，new拋出std::bad_alloc int *p2 = new (nothrow) int; //如果分配失敗，new返回一個空指針

4. 釋放動態內存

為了防止內存耗盡，在動態內存使用完畢后，必須將其歸還給系統。通過delete表達式來將動態內存歸還給系統。delete表達式接受一個指針，指向我們想要釋放的對象：

delete p; //p必須指向一個動態分配的對象或者是一個空指針。

delete表達式執行兩個動作：銷毀給定的指針指向的對象，釋放對應的內存

5. 指針值和delete

傳遞給delete的指針必須指向動態內存分配的內存，或者是一個空指針。釋放一塊非new分配的內存，或者將相同的指針值釋放多次，其行為是未定義的。

int i, *pi1 = &i, *pi2 = nullptr; double *pd = new double(33), *pd2 = pd; delete i; // 錯誤：i不是一個指針 delete pi1; // 未定義，pi1指向一個局部變量 delete pd; // 正確 delete pd2; // 未定義：pd2指向的內存已經被釋放了 delete pi2; // 正確，釋放一個空指針總是沒有錯誤的

對于delete i的請求，編譯器會生成一個錯誤信息，因為它知道i不是一個指針。

執行delete pi1和pd2所產生的錯誤則更具潛在危害：因為通常情況下，編譯器不能分辨一個指針指向的是靜態還是動態分配的對象。

類似的，編譯器也不能分辨一個指針所指向的內存是否已經被釋放掉了。

對于這些delete表達式，大多數編譯器會編譯通過，盡管是錯誤的。

const對象的值不能被改變，但本身是可以被銷毀的。

const int *pci = new const int(1024); delete pci; // 正確，釋放一個const對象

6. 動態對象的生存期直到被釋放為止

shared_ptr管理的內存在最后一個shared_ptr銷毀時會自動釋放。但對于通過內置指針類型來管理的動態對象，直到被顯式釋放之前都是存在的。

返回指向動態內存的指針的函數，調用者必須記得釋放內存。

// factory返回一個指針，指向一個動態分配的對象 Foo* factory(T arg){return new Foo(arg); //調用者負責釋放此內存 }

factory分配一個對象，但不delete，factory的調用者負責在不需要此對象時釋放。

void use_factory(T arg) {Foo *p = factory(arg); //使用*p但不delete } // p離開了它的作用域，但它指向的內存沒有被釋放

修正這個錯誤的正確方法是在use_factory中釋放內存

void use_factory(T arg) {Foo *p = factory(arg); // 使用pdelete p; }

如果系統中的其他代碼要使用use_factory所分配的對象，就要返回一個指針，指向它分配的內存

Foo* use_factory(T arg) {Foo *p = factory(arg); // 使用preturn p; //調用者必須釋放內存 }

使用new和delete管理動態內存三個常見問題

忘記delete內存。忘記釋放動態內存會導致“內存泄漏”問題，因為這種內存永遠不可能被歸還給自由空間了。查找內存泄漏問題是很難的，因為通常應用程序要運行很長時間后，真正耗盡內存時，才能檢測這種錯誤。

使用已經釋放掉的對象。通過在釋放內存后將指針置為空，有時候可以檢測出這種錯誤。

同一塊內存釋放兩次。當有兩個指針指向相同的動態分配對象時，可能發生這種錯誤。如果對其中一個指針進行delete操作，對象的內存就歸還給自由空間了，如果隨后又delete第二個指針，自由空間就可能被破壞。

---

3. shared_ptr和new結合使用

如果不初始化一個只能指針，就會被初始化為一個空指針。可以用new返回的指針來初始化智能指針。

shared_ptr p1; // shared_ptr可以指向一個double
shared_ptr p2(new int(1024)); // p2指向一個值為42的int

接受指針參數的智能指針構造函數是explicit的，因此，不能將一個內置指針隱式轉換為一個智能指針，必須使用直接初始化形式。

shared_ptr> p1 = new int(1024); // 錯誤：必須使用直接初始化形式
shared_ptr p2(new int(1024)); // 正確：使用了直接初始化形式

因為不能進行內置指針到智能指針的隱式轉換，因此第一條語句初始化是錯誤的，同樣，一個返回shared_ptr的函數不能在返回語句中隱式轉換一個普通指針。

shared_ptr clone(int p){
return new int§; //錯誤：隱式轉換為 shared_ptr
}

一個用來初始化智能指針的普通指針必須指向動態內存，因為智能指針默認使用delete釋放所關聯的對象。

可以將智能指針綁定到一個指向其他類型資源的指針上，但是為了這樣做，必須提供操作來代替delete。

定義和改變shared_ptr的其他方法

shared_ptr p(q)：p管理內置指針q所指向的對象，q必須指向new分配的內存，并且能夠轉換成T*類型

shared_ptr p(u)：p從unique_ptr u那里接管了對象的所有權，將u置為空

shared_ptr p(q, d)：p接管了內置指針q所指向對象的所有權，q必須能轉換為T*類型。p將使用可調用對象d來代替delete

shared_ptr p(p2, d)：p是shared_ptr p2的拷貝，唯一區別是p將用可調用對象d來代替delete

p.reset()：若p是唯一指向其對象的shared_ptr，reset會釋放此對象。

p.reset(q)：若傳遞了可選的參數內置指針q，會令p指向q，否則將p值為空。

p.reset(q, d)：如果還傳遞了參數d，將會調用d而不是delete來釋放q

1. 不要混合使用普通指針和智能指針

shared_ptr可以協調對象的析構，但僅限于自身的拷貝之間。這也就是為什么推薦使用make_shared而不是new的原因。這樣就能在分配對象的同時將shared_ptr與之綁定，從而避免了無意中將同一塊內存綁定到多個獨立創建的shared_ptr上。

//在函數被調用是ptr被創建并初始化
void process(shared_ptr ptr){
//使用ptr
} // ptr離開作用域被銷毀

process的參數是值傳遞方法，因此實參會被拷貝到ptr中，拷貝一個shared_ptr會遞增引用計數，因此，在process運行過程中，引用計數值至少為2。

當process結束時，ptr的引用計數會遞減，但不會變為0。因此當局部變量ptr被銷毀時，ptr指向的內存不會被釋放。

shared_ptr p(new int(42)); //引用計數為1
process§; //拷貝p會遞增它的引用計數，在process中引用計數值為2
int i = *p; //正確：引用計數為1

雖然不能傳遞給process一個內置指針，但可以傳遞一個臨時的shared_ptr，這個shared_ptr是用一個內置指針顯式構造的，但這樣很可能導致錯誤：

int x(new int(42));
process(x); //錯誤：不能將int 轉換為一個shared_ptr
process(shared_ptr(x)); //合法，但內存會被釋放
int j = *x; //未定義的，x是一個空懸指針

上面將一個臨時shared_ptr傳遞給process，當process結束時，臨時shared_ptr對象就被銷毀了，遞減引用計數，此時引用計數為0，所指向的內存會被釋放。x繼續指向已經釋放的內存，從而變成一個空懸指針。如果試圖使用x的值，是未定義的。

當將一個shared_ptr綁定到一個普通指針時，就將內存管理交給了shared_ptr，就不應該再使用內置指針來訪問shared_ptr所指向的內存了。

2. 也不要使用get初始化另一個指針指針或為智能指針賦值

智能指針的get函數返回一個內置指針，指向智能指針管理的對象。此函數是為這樣一種情況設計的：需要向不能使用智能指針的代碼傳遞一個內置指針，但使用get返回的指針的代碼不能delete此指針。

雖然編譯器不會給出錯誤信息，但將另一個智能指針也綁定到get返回的指針上是錯誤的：

shared_ptr p(new int(42)); //引用計數為1
int *q = p.get(); // 正確，但使用q要注意，不能讓它管理的指針被釋放
{
//未定義，兩個獨立的shared_ptr指向相同的內存
shared_ptr(q);
} // 程序塊結束，q被銷毀，指向的內存被釋放
int foo = *p; //未定義，p指向的內存已經被釋放了

p和q指向相同的內存，由于它們是相互獨立創建的，因此各自的引用計數為1.當q所在程序塊結束時，q被銷毀，導致q指向的內存被釋放，從而p變成一個空懸指針，此時使用p時將發生未定義的行為。

而且，當p被銷毀時，這塊內存會被第二次delete

3. 其他shared_ptr操作

shared_ptr定義了其他操作，可以用reset來講一個新的指針賦予一個shared_ptr

p = new int(42); //錯誤，不能想一個指針賦予shared_ptr
p.reset(new int(42)); //正確，p指向一個新對象

與賦值類似，reset會更新引用計數，如果需要的話，會釋放p指向的對象。reset成員經常與unique一起使用，來控制多個shared_ptr共享的對象。

在改變底層對象之前，需要檢查自己釋放是當前對象僅有的用戶，如果不是，在改變之前要制作一份新的拷貝：

if(!p.unique())
p.reset(new string(*p));
*p += newVal;

---

4. 智能指針和異常

程序需要確保異常發生后資源能被正確釋放，如果使用智能指針，即使程序過早結束也能確保在不需要時將其釋放。

void f(){
shared_ptr sp(new int(42)); //分配一個新對象
// 這段代碼拋出一個異常，且在f中未被捕獲
} // 在函數結束時shared_ptr自動釋放內存

當發生異常時，直接管理的內存是不會自動釋放的，如果使用內置指針管理內存，且在new之后在對應的delete之前發生了異常，則內存不會被釋放：

void f(){
int *ip = new int(42);
// 這段代碼拋出一個異常，且在f中未被捕獲
delete ip; // 在退出之前釋放內存
}

1. 智能指針和啞類

分配了資源，而又沒有定義析構函數來釋放這些資源的類，可能會遇到與使用動態內存相同的錯誤：忘記釋放資源。如果在資源分配和釋放之間發生了異常，程序也會發送資源泄漏。

struct destination; // 表示我們正在連接什么
struct connection; // 使用連接所需的信息
connection connect(destination*); // 打開連接
void f(destination &d){
//獲得一個連接，記住使用完要關閉
connection c = connect(&d);
//使用連接
//如果在f退出前忘記調用disconect，就無法關閉c
}

如果connection有一個析構函數，就可以在f結束時由析構函數自動關閉連接。但connection沒有析構函數，可以使用shared_ptr來保證connection被正確關閉。

2. 使用我們自己的釋放操作

默認情況下，shared_ptr假定它們指向的是動態內存，因此，當一個shared_ptr被銷毀時，它默認對它管理的指針進行delete操作。

為了用shared_ptr來管理一個connection，必須定義一個函數來代替delete。這個刪除函數必須能夠完成對shared_ptr中保存的指針進行釋放的操作。

我們的刪除器必須接受單個類型為connection *的參數：

void end_connection(connection *p) {disconect(*p);}

當創建一個shared_ptr時，可以傳遞一個指向刪除器函數的參數：

void f(destination &d){
connection c = connect(&d);
shared_ptr p(&c, end_connection);
//使用連接
//當f退出時（及時是由于異常而退出），connection會被正確關閉
}

當p被銷毀時，不會對自己保存的指針執行delete，而是調用end_connection。

如果f正常退出，那么p的銷毀會作為結束處理的一部分，如果發生了異常，p同樣會被銷毀，從而連接被關閉。

1. 智能指針陷阱

正確使用智能指針必須堅持的基本規范

不使用相同的內置指針值初始化（或reset）多個智能指針

不delete get()返回的指針

不適用get()初始化或reset另一個智能指針

如果使用get()返回的指針，最后一個對應的智能指針銷毀后，指針就變為無效了。

如果智能指針管理的資源不是new分配的內存，需要傳遞一個刪除器

---

5. unique_ptr

一個unique_ptr擁有它所指向的對象，與shared_ptr不同，某個時刻只能有一個unique_ptr指向一個給定對象。

當unique_ptr被銷毀時，所指的對象也被銷毀。

當定義一個unique_ptr時，需要將unique_ptr綁定到一個new返回的指針上。初始化unique_ptr必須采用直接初始化形式。

unique_ptr<double> p1; // 可以指向一個double的unique_ptr unique_ptr<int> p2(new int(42)); // p2指向一個值為42的int

由于unique_ptr擁有它指向的對象，因此unique_ptr不支持普通的拷貝或賦值操作

unique_ptr<string> p1(new string("hello)); unique_ptr<string> p2(p1); //錯誤：unique_ptr不支持拷貝 unique_ptr<string> p3; p3 = p2; //錯誤：unique_ptr不支持賦值

unique_ptr操作

unique_ptr u1：空unique_ptr，可以指向類型為T的讀寫，u1會使用delete來釋放它的指針。

unique_ptr<T, D> u2：u2會使用一個類型為D的可調用對象來釋放它的指針

unique_ptr<T, D> u(d)：空unique_ptr，指向類型為T的對象，用類型為D的對象d代替delete

u = nullptr：釋放u指向的對象，將u置為空

u.release()：u放棄對指針的控制權，返回指針，并將u置為空

u.reset()：釋放u指向的對象

u.reset(q)：如果提供了內置指針q，令u指向這個對象，否則將u置為空（u.reset(nullptr）

雖然不能拷貝或賦值unique_ptr，但可以通過調用release或reset將指針所有權從一個（非const）unique_ptr轉移給另一個unique_ptr：

// 將所有權從p1（指向hello）轉移給p2unique_ptr<string> p1(new string("hello"));unique_ptr<string> p2(p1.release()); // release將p1置為空unique_ptr<string> p3(new string("trex"));p2.reset(p3.release()); //將所有權從p3轉移給p2，reset釋放了p2原來指向的內存

release成員返回unique_ptr當前保存的指針并將其置為空。因此，p2被初始化為p1原來保存的指針，而p1被置為空。

reset成員接受一個可選的指針參數，令unique_ptr重新指向給定的指針。如果unique_ptr不為空，它原來指向的對象被釋放。因此，對p2調用reset釋放了用“hello”初始化的string所使用的內存，將p3對指針的所有權轉移給p2，并將p3置為空。

調用release會切斷unique_ptr和它原來管理的對象間的聯系，release返回的指針通常被用來初始化另一個智能指針或給另一個智能指針賦值。

如果我們不用另一個智能指針來保存release返回的指針，程序就要負責資源的釋放。

p2.release(); //錯誤，p2不會釋放內存，而且我們丟失了指針。 auto p = p2.release(); //正確，但我們必須記得delete(p)

1. 傳遞unique_ptr參數和返回unique_ptr

不能拷貝unique_ptr的規則有一個例外：可以拷貝或賦值一個將要被銷毀的unique_ptr。

unique_ptr<int> clone(int p){//正確：從int* 創建一個unique_ptr<int>return unique_ptr<int>(new int(p)); }

還可以返回一個局部對象的拷貝

unique_ptr<int> clone(int p){unique_ptr<int> ret(new int(p));// ...return ret; }

向后兼容：auto_ptr

標準庫的較早版本包含一個名為auto_ptr的類，具有unique_ptr的部分特性，但不是全部，特別是：不能在容器中保存auto_ptr，也不能從函數中返回auto_ptr

雖然auto_ptr是標準庫的一部分，但編寫程序時應該使用unique_ptr

2. 向unique_ptr傳遞刪除器

類似shared_ptr，unique_ptr默認情況下用delete釋放它指向的對象，我們可以重載一個unique_ptr默認的刪除器。

重載的刪除器必須在尖括號中unique_ptr指向類型之后提供刪除器類型，在創建或reset一個unique_ptr類型的對象時，必須提供一個指定類型的可調用對象（刪除器）

//p指向一個類型為objT的對象，并使用一個類型為delT的對象釋放objT對象
//它會調用一個名為fcn的delT類型對象
unique_ptr<objT, delT> p(new objT, fcn);

void f(destination &d){connection c = connect(&d); // 打開連接unique_ptr<connection, decltype(end_connection)*> p(&c,end_connection);//使用連接//當f退出時（即使是由于異常而退出），connection會被正常關閉 }

decltype用來指明函數指針類型，由于decltype(end_connection)返回一個函數類型，所以需要添加一個*來指出我們正在使用該類型的一個指針。

---

6. weak_ptr

weak_ptr是一種不控制所指向對象生存期的智能指針，指向一個shared_ptr管理的對象。將一個weak_ptr綁定到一個shread_ptr不會改變shared_ptr的引用計數。

一旦最后一個指向對象的shared_ptr被銷毀，對象就會被釋放。即使有weak_ptr指向對象，也會被釋放。

weak_ptr表

weak_ptr w：空weak_ptr可以指向類型為T的對象

weak_ptr w(sp)：與shared_ptr sp指向相同對象的weak_ptr，T必須能轉換為sp指向的類型

w = p：p可以是一個shared_ptr或一個weak_ptr。賦值后w與p共享對象。

w.reset：將w置為空

w.use_count：與w共享對象的shared_ptr的數量

w.expired()：若w.use_count()為0，返回true，否則返回false

w.lock：如果expired為true，返回一個空shared_ptr，否則返回一個指向w的對象的shared_ptr

當創建一個weak_ptr時，要用一個shared_ptr來初始化它：

auto p = make_shared(42);
weak_ptr wp§; // wp共享p；p的引用計數未改變

wp指向的對象可能被釋放掉，由于對象可能不存在，所以不能使用weak_ptr直接訪問對象，而必須調用lock來檢查weak_ptr指向的對象是否存在，如果存在，lock返回一個指向共享對象的shared_ptr。

if(shared_ptr np = wp.lock()){ //如果np不為空則條件成立
// 在if中，np與p共享對象。
}

總結

以上是生活随笔為你收集整理的C/C++学习之路: 智能指针的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。