0.前言

C++ 標(biāo)準(zhǔn)模板庫(kù) STL（Standard Template Library） 一共給我們提供了四種智能指針：auto_ptr、unique_ptr、shared_ptr 和 weak_ptr，其中 auto_ptr 是 C++98 提出的，C++11 已將其摒棄，并提出了 unique_ptr 替代 auto_ptr。雖然 auto_ptr 已被摒棄，但在實(shí)際項(xiàng)目中仍可使用，但建議使用更加安全的 unique_ptr，后文會(huì)詳細(xì)敘述。shared_ptr 和 weak_ptr 則是 C+11 從準(zhǔn)標(biāo)準(zhǔn)庫(kù) Boost 中引入的兩種智能指針。此外，Boost 庫(kù)還提出了 boost::scoped_ptr、boost::scoped_array、boost::intrusive_ptr 等智能指針，雖然尚未得到 C++ 標(biāo)準(zhǔn)采納，但是在開發(fā)實(shí)踐中可以使用。

1.unique_ptr

unique_ptr 由 C++11 引入，旨在替代不安全的 auto_ptr。unique_ptr 是一種定義在頭文件<memory>中的智能指針。它持有對(duì)對(duì)象的獨(dú)有權(quán)——兩個(gè)unique_ptr 不能指向一個(gè)對(duì)象，即 unique_ptr 不共享它所管理的對(duì)象。它無(wú)法復(fù)制到其他 unique_ptr，無(wú)法通過值傳遞到函數(shù)，也無(wú)法用于需要副本的任何標(biāo)準(zhǔn)模板庫(kù) （STL）算法。只能移動(dòng) unique_ptr，即對(duì)資源管理權(quán)限可以實(shí)現(xiàn)轉(zhuǎn)移。這意味著，內(nèi)存資源所有權(quán)可以轉(zhuǎn)移到另一個(gè) unique_ptr，并且原始 unique_ptr 不再擁有此資源。實(shí)際使用中，建議將對(duì)象限制為由一個(gè)所有者所有，因?yàn)槎鄠€(gè)所有權(quán)會(huì)使程序邏輯變得復(fù)雜。因此，當(dāng)需要智能指針用于存 C++ 對(duì)象時(shí)，可使用 unique_ptr，構(gòu)造 unique_ptr 時(shí)，可使用 make_unique Helper 函數(shù)。

下圖演示了兩個(gè) unique_ptr 實(shí)例之間的所有權(quán)轉(zhuǎn)換。

unique_ptr 與原始指針一樣有效，并可用于 STL 容器。將 unique_ptr 實(shí)例添加到 STL 容器運(yùn)行效率很高，因?yàn)橥ㄟ^ unique_ptr 的移動(dòng)構(gòu)造函數(shù)，不再需要進(jìn)行復(fù)制操作。unique_ptr 指針與其所指對(duì)象的關(guān)系：在智能指針生命周期內(nèi)，可以改變智能指針?biāo)笇?duì)象，如創(chuàng)建智能指針時(shí)通過構(gòu)造函數(shù)指定、通過 reset 方法重新指定、通過 release 方法釋放所有權(quán)、通過移動(dòng)語(yǔ)義轉(zhuǎn)移所有權(quán)，unique_ptr 還可能沒有對(duì)象，這種情況被稱為 empty。[ 6 ] ^{[6]} [6]。

unique_ptr的基本操作有：

// 智能指針的創(chuàng)建
unique_ptr<int> u_i; 	//創(chuàng)建空智能指針
u_i.reset(new int(3)); 	//綁定動(dòng)態(tài)對(duì)象  
unique_ptr<int> u_i2(new int(4));//創(chuàng)建時(shí)指定動(dòng)態(tài)對(duì)象
unique_ptr<T,D> u(d);	//創(chuàng)建空 unique_ptr，執(zhí)行類型為 T 的對(duì)象，用類型為 D 的對(duì)象 d 來替代默認(rèn)的刪除器 delete
 
// 所有權(quán)的變化  
int *p_i = u_i2.release();	//釋放所有權(quán)  
unique_ptr<string> u_s(new string("abc"));  
unique_ptr<string> u_s2 = std::move(u_s); //所有權(quán)轉(zhuǎn)移(通過移動(dòng)語(yǔ)義)，u_s所有權(quán)轉(zhuǎn)移后，變成“空指針” 
u_s2.reset(u_s.release());	//所有權(quán)轉(zhuǎn)移
u_s2=nullptr;//顯式銷毀所指對(duì)象，同時(shí)智能指針變?yōu)榭罩羔?。與u_s2.reset()等價(jià)

2.auto_ptr

auto_ptr 同樣是 STL 智能指針家族的成員之一，由 C++98 引入，定義在頭文件<memory>。其功能和用法類似于 unique_ptr，由 new expression 獲得對(duì)象，在 auto_ptr 對(duì)象銷毀時(shí)，他所管理的對(duì)象也會(huì)自動(dòng)被 delete 掉。

auto_ptr 從 C++98 使用至今，為何從 C++11 開始，引入 unique_ptr 來替代 auto_ptr 呢？原因主要有如下幾點(diǎn)：

（1）基于安全考慮。
先來看下面的賦值語(yǔ)句:

auto_ptr< string> ps (new string ("I reigned lonely as a cloud.”）;
auto_ptr<string> vocation; 
vocaticn = ps;

上述賦值語(yǔ)句將完成什么工作呢？如果 ps 和 vocation 是常規(guī)指針，則兩個(gè)指針將指向同一個(gè) string 對(duì)象。這是不能接受的，因?yàn)槌绦驅(qū)⒃噲D刪除同一個(gè)對(duì)象兩次，一次是 ps 過期時(shí)，另一次是 vocation 過期時(shí)。要避免這種問題，方法有多種：
（a）定義陚值運(yùn)算符，使之執(zhí)行深復(fù)制。這樣兩個(gè)指針將指向不同的對(duì)象，其中的一個(gè)對(duì)象是另一個(gè)對(duì)象的副本，缺點(diǎn)是浪費(fèi)空間，所以智能指針都未采用此方案。
（b）建立所有權(quán)（ownership）概念。對(duì)于特定的對(duì)象，只能有一個(gè)智能指針可擁有，這樣只有擁有對(duì)象的智能指針的析構(gòu)函數(shù)會(huì)刪除該對(duì)象。然后讓賦值操作轉(zhuǎn)讓所有權(quán)。這就是用于 auto_ptr 和 unique_ptr 的策略，但 unique_ptr 的策略更嚴(yán)格。
（c）創(chuàng)建智能更高的指針，跟蹤引用特定對(duì)象的智能指針數(shù)。這稱為引用計(jì)數(shù)。例如，賦值時(shí)，計(jì)數(shù)將加 1，而指針過期時(shí)，計(jì)數(shù)將減 1,。當(dāng)減為 0 時(shí)才調(diào)用 delete。這是 shared_ptr 采用的策略。

當(dāng)然，同樣的策略也適用于復(fù)制構(gòu)造函數(shù)，即auto_ptr<string> vocation(ps)時(shí)也需要上面的策略。每種方法都有其用途，但為何要摒棄 auto_ptr 呢？

下面舉個(gè)例子來說明。

#include <iostream>
#include <string>
#include <memory>
using namespace std;
 
int main() {
	auto_ptr<string> films[5] ={
	auto_ptr<string> (new string("Fowl Balls")),
	auto_ptr<string> (new string("Duck Walks")),
	auto_ptr<string> (new string("Chicken Runs")),
	auto_ptr<string> (new string("Turkey Errors")),
	auto_ptr<string> (new string("Goose Eggs"))
	};
    auto_ptr<string> pwin;
    pwin = films[2]; // films[2] loses ownership. 將所有權(quán)從films[2]轉(zhuǎn)讓給pwin，此時(shí)films[2]不再引用該字符串從而變成空指針
 
	cout << "The nominees for best avian baseballl film are\n";
	for(int i = 0; i < 5; ++i) {
		cout << *films[i] << endl;
	}
 	cout << "The winner is " << *pwin << endl;
	return 0;
}

運(yùn)行下發(fā)現(xiàn)程序崩潰了，原因在上面注釋已經(jīng)說的很清楚，films[2] 已經(jīng)是空指針了，下面輸出訪問空指針當(dāng)然會(huì)崩潰了。但這里如果把 auto_ptr 換成 shared_ptr 或 unique_ptr 后，程序就不會(huì)崩潰，原因如下：

使用 shared_ptr 時(shí)運(yùn)行正常，因?yàn)?shared_ptr 采用引用計(jì)數(shù)，pwin 和 films[2] 都指向同一塊內(nèi)存，在釋放空間時(shí)因?yàn)槭孪纫袛嘁糜?jì)數(shù)值的大小因此不會(huì)出現(xiàn)多次刪除一個(gè)對(duì)象的錯(cuò)誤。

使用 unique_ptr 時(shí)編譯出錯(cuò)，與 auto_ptr 一樣，unique_ptr 也采用所有權(quán)模型，但在使用 unique_ptr 時(shí)，程序不會(huì)等到運(yùn)行階段崩潰，而在編譯期因下述代碼行出現(xiàn)錯(cuò)誤：

unique_ptr<string> pwin;
pwin = films[2]; 					// films[2] loses ownership

指導(dǎo)你發(fā)現(xiàn)潛在的內(nèi)存錯(cuò)誤。這就是為何要摒棄 auto_ptr 的原因，一句話總結(jié)就是：避免因潛在的內(nèi)存問題導(dǎo)致程序崩潰。

從上面可見，unique_ptr 比 auto_ptr 更加安全，因?yàn)?auto_ptr 有拷貝語(yǔ)義，拷貝后原對(duì)象變得無(wú)效，再次訪問原對(duì)象時(shí)會(huì)導(dǎo)致程序崩潰；unique_ptr 則禁止了拷貝語(yǔ)義，但提供了移動(dòng)語(yǔ)義，即可以使用 std::move() 進(jìn)行控制權(quán)限的轉(zhuǎn)移，如下代碼所示：

unique_ptr<string> upt(new string("lvlv"));
unique_ptr<string> upt1(upt);	//編譯出錯(cuò)，已禁止拷貝
unique_ptr<string> upt1=upt;	//編譯出錯(cuò)，已禁止拷貝
unique_ptr<string> upt1=std::move(upt);  //控制權(quán)限轉(zhuǎn)移
 
auto_ptr<string> apt(new string("lvlv"));
auto_ptr<string> apt1(apt);	//編譯通過
auto_ptr<string> apt1=apt;	//編譯通過

這里要注意，在使用 std::move 將 unique_ptr 的控制權(quán)限轉(zhuǎn)移后，不能夠再通過 unique_ptr 來訪問和控制資源了，否則同樣會(huì)出現(xiàn)程序崩潰。我們可以在使用 unique_ptr 訪問資源前，使用成員函數(shù) get() 進(jìn)行判空操作。

unique_ptr<string> upt1=std::move(upt);	// 控制權(quán)限轉(zhuǎn)移
if(upt.get()!=nullptr) {				// 判空操作更安全
	// do something
}

（2）unique_ptr 不僅安全，而且靈活。
如果 unique_ptr 是個(gè)臨時(shí)右值，編譯器允許拷貝語(yǔ)義。參考如下代碼：

unique_ptr<string> demo(const char* s) {
    unique_ptr<string> temp (new string(s))； 
    return temp；
}
 
// 假設(shè)編寫了如下代碼：
unique_ptr<string> ps;
ps = demo('Uniquely special")；

demo() 返回一個(gè)臨時(shí) unique_ptr，然后 ps 接管了臨時(shí)對(duì)象 unique_ptr 所管理的資源，而返回時(shí)臨時(shí)的 unique_ptr 被銷毀，也就是說沒有機(jī)會(huì)使用 unique_ptr 來訪問無(wú)效的數(shù)據(jù)，換句話來說，這種賦值是不會(huì)出現(xiàn)任何問題的，即沒有理由禁止這種賦值。實(shí)際上，編譯器確實(shí)允許這種賦值。相對(duì)于 auto_ptr 任何情況下都允許拷貝語(yǔ)義，這正是 unique_ptr 更加靈活聰明的地方。

（3）擴(kuò)展 auto_ptr 不能完成的功能。
（a）unique_ptr 可放在容器中，彌補(bǔ)了 auto_ptr 不能作為容器元素的缺點(diǎn)。

// 方式一
vector<unique_ptr<string>> vs { new string{“Doug”}, new string{“Adams”} };  
 
// 方式二
vector<unique_ptr<string>>v;  
unique_ptr<string> p1(new string("abc"));

（b）管理動(dòng)態(tài)數(shù)組，因?yàn)?unique_ptr 有 unique_ptr<X[]> 重載版本，銷毀動(dòng)態(tài)對(duì)象時(shí)調(diào)用 delete[]。

unique_ptr<int[]> p (new int[3]{1,2,3});  
p[0] = 0;// 重載了operator[]

（c）自定義資源刪除操作（Deleter）。unique_ptr 默認(rèn)的資源刪除操作是 delete/delete[]，若需要可以進(jìn)行自定義：

void end_connection(connection *p) { disconnect(*p); } // 資源清理函數(shù)  
 
// 資源清理器的類型
unique_ptr<connection, decltype(end_connection)*> p(&c, end_connection);// 傳入函數(shù)名，會(huì)自動(dòng)轉(zhuǎn)換為函數(shù)指針

綜上所述，基于 unique_ptr 的安全性和擴(kuò)充的功能，unique_ptr 成功的將 auto_ptr 取而代之。

3.shared_ptr

 3.1 簡(jiǎn)介

shared_ptr 是一個(gè)標(biāo)準(zhǔn)的共享所有權(quán)的智能指針，允許多個(gè)指針指向同一個(gè)對(duì)象，定義在 memory 文件中，命名空間為 std。shared_ptr最初實(shí)現(xiàn)于Boost庫(kù)中，后由 C++11 引入到 C++ STL。shared_ptr 利用引用計(jì)數(shù)的方式實(shí)現(xiàn)了對(duì)所管理的對(duì)象的所有權(quán)的分享，即允許多個(gè) shared_ptr 共同管理同一個(gè)對(duì)象。像 shared_ptr 這種智能指針，《Effective C++》稱之為“引用計(jì)數(shù)型智能指針”（reference-counting smart pointer，RCSP）。

shared_ptr 是為了解決 auto_ptr 在對(duì)象所有權(quán)上的局限性（auto_ptr 是獨(dú)占的），在使用引用計(jì)數(shù)的機(jī)制上提供了可以共享所有權(quán)的智能指針，當(dāng)然這需要額外的開銷：
（1）shared_ptr 對(duì)象除了包括一個(gè)所擁有對(duì)象的指針外，還必須包括一個(gè)引用計(jì)數(shù)代理對(duì)象的指針；
（2）時(shí)間上的開銷主要在初始化和拷貝操作上， * 和 -> 操作符重載的開銷跟 auto_ptr 是一樣；
（3）開銷并不是我們不使用 shared_ptr 的理由,，永遠(yuǎn)不要進(jìn)行不成熟的優(yōu)化，直到性能分析器告訴你這一點(diǎn)。

3.2 通過輔助類模擬實(shí)現(xiàn) shared_ptr

（1）基礎(chǔ)對(duì)象類
首先，我們來定義一個(gè)基礎(chǔ)對(duì)象類 Point 類，為了方便后面我們驗(yàn)證智能指針是否有效，我們?yōu)?Point 類創(chuàng)建如下接口：

class Point {
private:
    int x, y;
public:
    Point(int xVal = 0, int yVal = 0) :x(xVal), y(yVal) {}
    int getX() const { return x; }
    int getY() const { return y; }
    void setX(int xVal) { x = xVal; }
    void setY(int yVal) { y = yVal; }
};

（2）輔助類
在創(chuàng)建智能指針類之前，我們先創(chuàng)建一個(gè)輔助類。這個(gè)類的所有成員皆為私有類型，因?yàn)樗槐黄胀ㄓ脩羲褂?。為了只為智能指針使用，還需要把智能指針類聲明為輔助類的友元。這個(gè)輔助類含有兩個(gè)數(shù)據(jù)成員：計(jì)數(shù) count 與基礎(chǔ)對(duì)象指針。也即輔助類用以封裝使用計(jì)數(shù)與基礎(chǔ)對(duì)象指針。

class RefPtr {
private:
    friend class SmartPtr;      
    RefPtr(Point *ptr):p(ptr),count(1){}
    ~RefPtr(){delete p;}
    
    int count;   
    Point *p;                                                      
};

（3）為基礎(chǔ)對(duì)象類實(shí)現(xiàn)智能指針類
引用計(jì)數(shù)是實(shí)現(xiàn)智能指針的一種通用方法。智能指針將一個(gè)計(jì)數(shù)器與類指向的對(duì)象相關(guān)聯(lián)，引用計(jì)數(shù)跟蹤共有多少個(gè)類對(duì)象共享同一指針。它的具體做法如下：
（a）當(dāng)創(chuàng)建智能指針類的新對(duì)象時(shí)，初始化指針，并將引用計(jì)數(shù)設(shè)置為1；
（b）當(dāng)能智能指針類對(duì)象作為另一個(gè)對(duì)象的副本時(shí)，拷貝構(gòu)造函數(shù)復(fù)制副本的指向輔助類對(duì)象的指針，并增加輔助類對(duì)象對(duì)基礎(chǔ)類對(duì)象的引用計(jì)數(shù)（加1）；
（c）使用賦值操作符對(duì)一個(gè)智能指針類對(duì)象進(jìn)行賦值時(shí)，處理復(fù)雜一點(diǎn)：先使左操作數(shù)的引用計(jì)數(shù)減 1（為何減 1：因?yàn)橹羔樢呀?jīng)指向別的地方），如果減1后引用計(jì)數(shù)為 0，則釋放指針?biāo)笇?duì)象內(nèi)存。然后增加右操作數(shù)所指對(duì)象的引用計(jì)數(shù)（為何增加：因?yàn)榇藭r(shí)做操作數(shù)指向?qū)ο蠹从也僮鲾?shù)指向?qū)ο螅?br /> （d）完成析構(gòu)函數(shù)：調(diào)用析構(gòu)函數(shù)時(shí)，析構(gòu)函數(shù)先使引用計(jì)數(shù)減 1，如果減至 0 則 delete 對(duì)象。

做好前面的準(zhǔn)備后，我們可以為基礎(chǔ)對(duì)象類 Point 書寫一個(gè)智能指針類了。根據(jù)引用計(jì)數(shù)實(shí)現(xiàn)關(guān)鍵點(diǎn)，我們可以寫出如下智能指針類：

class SmartPtr {
public:
	//構(gòu)造函數(shù)
	SmartPtr() { rp = nullptr; }
	SmartPtr(Point *ptr):rp(new RefPtr(ptr)) {}
	SmartPtr(const SmartPtr &sp):rp(sp.rp) { 
		++rp->count;
		cout << "in copy constructor" <<endl;
	}
	
	// 重載賦值運(yùn)算符
	SmartPtr& operator=(const SmartPtr& rhs) {
		++rhs.rp->count;
		if (rp != nullptr && --rp->count == 0) {
			delete rp;
		}
		rp = rhs.rp;
		cout << "in assignment operator" << endl;
		return *this;
	}
	
	// 重載->操作符
	Point* operator->() {
		return rp->p;
	}
	
	// 重載*操作符
	Point& operator*() {
		return *(rp->p);
	}
 
	~SmartPtr() {
		if (--rp->count == 0) delete rp;
		else cout << "還有" << rp->count << "個(gè)指針指向基礎(chǔ)對(duì)象" << endl;
	}
 
private:
	RefPtr* rp;
};

（4）智能指針類的使用與測(cè)試
至此，我們的智能指針類就完成了，我們可以來看看如何使用。

int main() {
    //定義一個(gè)基礎(chǔ)對(duì)象類指針
    Point *pa = new Point(10, 20);
 
    // 定義三個(gè)智能指針類對(duì)象，對(duì)象都指向基礎(chǔ)類對(duì)象 pa
    // 使用花括號(hào)控制三個(gè)智能指針的生命周期，觀察計(jì)數(shù)的變化
    {
        SmartPtr sptr1(pa);// 此時(shí)計(jì)數(shù) count=1
        cout << "sptr1:" << sptr1->getX() << "," << sptr1->getY() <<endl;
        {
            SmartPtr sptr2(sptr1); // 調(diào)用拷貝構(gòu)造函數(shù)，此時(shí)計(jì)數(shù)為 count=2
            cout<< "sptr2:" << sptr2->getX() << "," << sptr2->getY() <<endl;
            {
            	SmartPtr sptr3;
                SmartPtr sptr3=sptr1; // 調(diào)用賦值操作符，此時(shí)計(jì)數(shù)為 conut=3
                cout<<"sptr3:"<<(*sptr3).getX()<<","<<(*sptr3).getY()<<endl;
            }
            //此時(shí)count=2
        }
        //此時(shí)count=1；
    }
    // 此時(shí)count=0；對(duì)象 pa 被 delete 掉
    cout << pa->getX() << endl;
    return 0;
}

運(yùn)行結(jié)果：

sptr1:10,20
in copy constructor
sptr2:10,20
in assignment operator
sptr3:10,20
還有2個(gè)指針指向基礎(chǔ)對(duì)象
還有1個(gè)指針指向基礎(chǔ)對(duì)象
-572662307

如期，在離開大括號(hào)后，共享基礎(chǔ)對(duì)象的指針從 3->2->1->0 變換，最后計(jì)數(shù)為 0 時(shí)，pa 對(duì)象被 delete，此時(shí)使用 getX() 已經(jīng)獲取不到原來的值。

（5）對(duì)智能指針的改進(jìn)
目前這個(gè)智能指針只能用于管理 Point 類的基礎(chǔ)對(duì)象，如果此時(shí)定義了個(gè)矩陣的基礎(chǔ)對(duì)象類，那不是還得重新寫一個(gè)屬于矩陣類的智能指針類嗎？但是矩陣類的智能指針類設(shè)計(jì)思想和 Poin t類一樣啊，就不能借用嗎？答案當(dāng)然是能，那就是使用模板技術(shù)。為了使我們的智能指針適用于更多的基礎(chǔ)對(duì)象類，我們有必要把智能指針類通過模板來實(shí)現(xiàn)。這里貼上上面智能指針類的模板版本：

//模板類作為友元時(shí)要先有聲明
template <typename T> class SmartPtr;
   
//輔助類
template <typename T> class RefPtr {
private:
    //該類成員訪問權(quán)限全部為private，因?yàn)椴幌胱層脩糁苯邮褂迷擃?
    friend class SmartPtr<T>;      //定義智能指針類為友元，因?yàn)橹悄苤羔橆愋枰苯硬倏v輔助類
    
    //構(gòu)造函數(shù)的參數(shù)為基礎(chǔ)對(duì)象的指針
    RefPtr(T *ptr):p(ptr), count(1){}
    
    //析構(gòu)函數(shù)
    ~RefPtr() {
    	delete p;
    }
    
    //引用計(jì)數(shù)
    int count;   
    
    //基礎(chǔ)對(duì)象指針
    T *p;                                                      
};
 
// 智能指針類
template<typename T> class SmartPtr {
public:
	// 構(gòu)造函數(shù)
    SmartPtr(T *ptr):rp(new RefPtr<T>(ptr))
    {}
    // 拷貝構(gòu)造函數(shù)
    SmartPtr(const SmartPtr<T> &sp):rp(sp.rp)
    {
    	++rp->count;
    }
    //重載賦值操作符
    SmartPtr& operator=(const SmartPtr<T>& rhs)
    {
        ++rhs.rp->count;        //首先將右操作數(shù)引用計(jì)數(shù)加1，
        if (--rp->count == 0)   //然后將引用計(jì)數(shù)減1，可以應(yīng)對(duì)自賦值
            delete rp;
        rp = rhs.rp;
        return *this;
    }
    // 重載*操作符
    T & operator *()
    {
        return *(rp->p);
    }
    // 重載->操作符
    T* operator ->()
    {
        return rp->p;
    }
    // 析構(gòu)函數(shù)
    ~SmartPtr() {
        if (--rp->count == 0) { // 當(dāng)引用計(jì)數(shù)減為 0 時(shí)，刪除輔助類對(duì)象指針，從而刪除基礎(chǔ)對(duì)象
        	delete rp;
        } else {
	        cout << "還有" << rp->count << "個(gè)指針指向基礎(chǔ)對(duì)象" << endl;
	    }
    }
private:
    RefPtr<T> *rp;  //輔助類對(duì)象指針
};

現(xiàn)在使用智能指針類模板來共享其它類型的基礎(chǔ)對(duì)象，以 int 為例：

int main() {
	// 定義一個(gè)基礎(chǔ)對(duì)象類指針
    int* ia = new int(10);
    {
        SmartPtr<int> sptr1(ia);
        cout <<"sptr1:"<<*sptr1<<endl;
        {
            SmartPtr<int> sptr2(sptr1); 
            cout <<"sptr2:"<<*sptr2<<endl;
			*sptr2=5;
            {
                SmartPtr<int> sptr3=sptr1; 
                cout <<"sptr3:"<<*sptr3<<endl;
            }
        }
    }
    // 此時(shí)count=0，pa 對(duì)象被 delete 掉
    cout << *ia << endl;
    return 0;
}

測(cè)試結(jié)果如下：

sptr1:10
sptr2:10
sptr3:5
還有2個(gè)指針指向基礎(chǔ)對(duì)象
還有1個(gè)指針指向基礎(chǔ)對(duì)象
3968064

4.weak_ptr

4.1 簡(jiǎn)介

weak_ptr 被設(shè)計(jì)為與 shared_ptr 共同工作，可以從一個(gè) shared_ptr 或者另一個(gè) weak_ptr 對(duì)象構(gòu)造而來。weak_ptr 是為了配合 shared_ptr 而引入的一種智能指針，它更像是 shared_ptr 的一個(gè)助手而不是智能指針，因?yàn)樗痪哂衅胀ㄖ羔樀男袨?，沒有重載 operator* 和 operator-> ，因此取名為 weak，表明其是功能較弱的智能指針。它的最大作用在于協(xié)助 shared_ptr 工作，可獲得資源的觀測(cè)權(quán)，像旁觀者那樣觀測(cè)資源的使用情況。觀察者意味著 weak_ptr 只對(duì) shared_ptr 進(jìn)行引用，而不改變其引用計(jì)數(shù)，當(dāng)被觀察的 shared_ptr 失效后，相應(yīng)的 weak_ptr 也相應(yīng)失效。

4.2 用法

使用 weak_ptr 的成員函數(shù) use_count() 可以觀測(cè)資源的引用計(jì)數(shù)，另一個(gè)成員函數(shù) expired() 的功能等價(jià)于 use_count()==0，但更快，表示被觀測(cè)的資源（也就是 shared_ptr 管理的資源）已經(jīng)不復(fù)存在。weak_ptr 可以使用一個(gè)非常重要的成員函數(shù)lock()從被觀測(cè)的 shared_ptr 獲得一個(gè)可用的 shared_ptr 管理的對(duì)象， 從而操作資源。但當(dāng) expired()==true 的時(shí)候，lock() 函數(shù)將返回一個(gè)存儲(chǔ)空指針的 shared_ptr?？偟膩碚f，weak_ptr 的基本用法總結(jié)如下：

weak_ptr<T> w;	 	//創(chuàng)建空 weak_ptr，可以指向類型為 T 的對(duì)象
weak_ptr<T> w(sp);	//與 shared_ptr 指向相同的對(duì)象，shared_ptr 引用計(jì)數(shù)不變。T必須能轉(zhuǎn)換為 sp 指向的類型
w=p;				//p 可以是 shared_ptr 或 weak_ptr，賦值后 w 與 p 共享對(duì)象
w.reset();			//將 w 置空
w.use_count();		//返回與 w 共享對(duì)象的 shared_ptr 的數(shù)量
w.expired();		//若 w.use_count() 為 0，返回 true，否則返回 false
w.lock();			//如果 expired() 為 true，返回一個(gè)空 shared_ptr，否則返回非空 shared_ptr

下面是一個(gè)簡(jiǎn)單的使用示例：

#include < assert.h>
 
#include <iostream>
#include <memory>
#include <string>
 
using namespace std;
 
int main() {
	shared_ptr<int> sp(new int(10));
	assert(sp.use_count() == 1);
	weak_ptr<int> wp(sp); 	//從 shared_ptr 創(chuàng)建 weak_ptr
	assert(wp.use_count() == 1);
	if (!wp.expired())		//判斷 weak_ptr 觀察的對(duì)象是否失效
	{
		shared_ptr<int> sp2 = wp.lock();//獲得一個(gè)shared_ptr
		*sp2 = 100;
		assert(wp.use_count() == 2);
	}
	assert(wp.use_count() == 1);
	cout << "int:" << *sp << endl;
    return 0;
}

程序輸出：

int：100

從上面可以看到，盡管以 shared_ptr 來構(gòu)造 weak_ptr，但是 weak_ptr 內(nèi)部的引用計(jì)數(shù)并沒有什么變化。

4.3 作用

現(xiàn)在要說的問題是，weak_ptr 到底有什么作用呢？從上面那個(gè)例子看來，似乎沒有任何作用。其實(shí) weak_ptr 可用于打破循環(huán)引用。引用計(jì)數(shù)是一種便利的內(nèi)存管理機(jī)制，但它有一個(gè)很大的缺點(diǎn)，那就是不能管理循環(huán)引用的對(duì)象。一個(gè)簡(jiǎn)單的例子如下：

#include <iostream>
#include <memory>
  
class Woman;  
class Man {
private:  
    //std::weak_ptr<Woman> _wife;  
    std::shared_ptr<Woman> _wife;  
public:  
    void setWife(std::shared_ptr<Woman> woman) {  
        _wife = woman;  
    }  
  
    void doSomthing() {  
        if(_wife.lock()){}  
    }  
  
    ~Man() {
        std::cout << "kill man\n";  
    }  
};  
  
class Woman {  
private:  
    //std::weak_ptr<Man> _husband;  
    std::shared_ptr<Man> _husband;  
public:  
    void setHusband(std::shared_ptr<Man> man) {  
        _husband = man;  
    }  
    ~Woman() {  
        std::cout <<"kill woman\n";  
    }  
};
 
int main(int argc, char** argv) {  
    std::shared_ptr<Man> m(new Man());  
    std::shared_ptr<Woman> w(new Woman());  
    if(m && w) {  
        m->setWife(w);  
        w->setHusband(m);  
    }  
    return 0;  
}

在 Man 類內(nèi)部會(huì)引用一個(gè) Woman，Woman 類內(nèi)部也引用一個(gè) Man。當(dāng)一個(gè) man 和一個(gè) woman 是夫妻的時(shí)候，他們直接就存在了相互引用問題。man 內(nèi)部有個(gè)用于管理wife生命期的 shared_ptr 變量，也就是說 wife 必定是在 husband 去世之后才能去世。同樣的，woman 內(nèi)部也有一個(gè)管理 husband 生命期的 shared_ptr 變量，也就是說 husband 必須在 wife 去世之后才能去世。這就是循環(huán)引用存在的問題：husband 的生命期由 wife 的生命期決定，wife 的生命期由 husband 的生命期決定，最后兩人都死不掉，違反了自然規(guī)律，導(dǎo)致了內(nèi)存泄漏。

一般來講，解除這種循環(huán)引用有下面三種可行的方法：
（1）當(dāng)只剩下最后一個(gè)引用的時(shí)候需要手動(dòng)打破循環(huán)引用釋放對(duì)象。
（2）當(dāng) parent 的生存期超過 children 的生存期的時(shí)候，children 改為使用一個(gè)普通指針指向 parent。
（3）使用弱引用的智能指針打破這種循環(huán)引用。
雖然這三種方法都可行，但方法 1 和方法 2 都需要程序員手動(dòng)控制，麻煩且容易出錯(cuò)。這里主要介紹一下第三種方法，使用弱引用的智能指針std:weak_ptr 來打破循環(huán)引用。

weak_ptr 對(duì)象引用資源時(shí)不會(huì)增加引用計(jì)數(shù)，但是它能夠通過 lock() 方法來判斷它所管理的資源是否被釋放。做法就是上面的代碼注釋的地方取消注釋，取消 Woman 類或者 Man 類的任意一個(gè)即可，也可同時(shí)取消注釋，全部換成弱引用 weak_ptr。

另外很自然地一個(gè)問題是：既然 weak_ptr 不增加資源的引用計(jì)數(shù)，那么在使用 weak_ptr 對(duì)象的時(shí)候，資源被突然釋放了怎么辦呢？不用擔(dān)心，因?yàn)椴荒苤苯油ㄟ^ weak_ptr 來訪問資源。那么如何通過 weak_ptr 來間接訪問資源呢？答案是在需要訪問資源的時(shí)候 weak_ptr 為你生成一個(gè)shared_ptr，shared_ptr 能夠保證在 shared_ptr 沒有被釋放之前，其所管理的資源是不會(huì)被釋放的。創(chuàng)建 shared_ptr 的方法就是 lock() 成員函數(shù)。

注意： shared_ptr 實(shí)現(xiàn)了 operator bool() const 方法來判斷被管理的資源是否已被釋放。

5.如何選擇智能指針

上文簡(jiǎn)單地介紹了 C++ STL 的四種智能指針。當(dāng)然，除了 STL 的智能指針，C++ 準(zhǔn)標(biāo)準(zhǔn)庫(kù) Boost 的智能指針，比如 boost::scoped_ptr、boost::shared_array、boost::intrusive_ptr 也可以在編程實(shí)踐中拿來使用，但這里不做進(jìn)一步的介紹，有興趣的讀者可以參考：C++ 智能指針詳解。

在了解 STL 的四種智能指針后，大家可能會(huì)想另一個(gè)問題：在實(shí)際應(yīng)用中，應(yīng)使用哪種智能指針呢？

下面給出幾個(gè)使用指南。
（1）如果程序要使用多個(gè)指向同一個(gè)對(duì)象的指針，應(yīng)選擇 shared_ptr。這樣的情況包括：
（a）將指針作為參數(shù)或者函數(shù)的返回值進(jìn)行傳遞的話，應(yīng)該使用 shared_ptr；
（b）兩個(gè)對(duì)象都包含指向第三個(gè)對(duì)象的指針，此時(shí)應(yīng)該使用 shared_ptr 來管理第三個(gè)對(duì)象；
（c）STL 容器包含指針。很多 STL 算法都支持復(fù)制和賦值操作，這些操作可用于 shared_ptr，但不能用于 unique_ptr（編譯器發(fā)出 warning）和 auto_ptr（行為不確定）。如果你的編譯器沒有提供 shared_ptr，可使用 Boost 庫(kù)提供的 shared_ptr。

（2）如果程序不需要多個(gè)指向同一個(gè)對(duì)象的指針，則可使用 unique_ptr。如果函數(shù)使用 new 分配內(nèi)存，并返還指向該內(nèi)存的指針，將其返回類型聲明為 unique_ptr 是不錯(cuò)的選擇。這樣，所有權(quán)轉(zhuǎn)讓給接受返回值的 unique_ptr，而該智能指針將負(fù)責(zé)調(diào)用 delete?？蓪?unique_ptr 存儲(chǔ)到 STL 容器中，只要對(duì)容器元素不使用拷貝操作的算法即可（如 sort()）。例如，可在程序中使用類似于下面的代碼段。

unique_ptr<int> make_int(int n) {
    return unique_ptr<int>(new int(n));
}
 
void show(unique_ptr<int>& p1) {
    cout << *p1 << ' ';
}
 
int main() {
	//...
    vector<unique_ptr<int>> vp(size);
    for(int i = 0; i < vp.size(); i++)
    {
		vp[i] = make_int(rand() % 1000);       //copy temporary unique_ptr
	}
    vp.push_back(make_int(rand() % 1000));     //ok because arg is temporary
    for_each(vp.begin(), vp.end(), show);      //use for_each()
	//...
}

其中 push_back 調(diào)用沒有問題，因?yàn)樗祷匾粋€(gè)臨時(shí) unique_ptr，該 unique_ptr 被賦給 vp 中的一個(gè) unique_ptr。另外，如果按值而不是按引用給 show() 傳遞對(duì)象，for_each() 將非法，因?yàn)檫@將導(dǎo)致使用一個(gè)來自 vp 的非臨時(shí) unique_ptr 初始化 pi，而這是不允許的。前面說過，編譯器將發(fā)現(xiàn)錯(cuò)誤使用 unique_ptr 的企圖。

在 unique_ptr 為右值時(shí)，可將其賦給 shared_ptr，這與將一個(gè) unique_ptr 賦給另一個(gè) unique_ptr 需要滿足的條件相同，即 unique_ptr 必須是一個(gè)臨時(shí)對(duì)象。與前面一樣，在下面的代碼中，make_int() 的返回類型為 unique_ptr<int>：

unique_ptr<int> pup(make_int(rand() % 1000));		// ok
shared_ptr<int> spp(pup);										// not allowed, pup as lvalue
shared_ptr<int> spr(make_int(rand() % 1000));    	// ok

模板 shared_ptr 包含一個(gè)顯式構(gòu)造函數(shù)，可用于將右值 unique_ptr 轉(zhuǎn)換為 shared_ptr。shared_ptr 將接管原來歸 unique_ptr 所有的對(duì)象。

在滿足 unique_ptr 要求的條件時(shí)，也可使用 auto_ptr，但 unique_ptr 是更好的選擇。如果你的編譯器沒有unique_ptr，可考慮使用 Boost 庫(kù)提供的 scoped_ptr，它與 unique_ptr 類似。

（3）雖然說在滿足 unique_ptr 要求的條件時(shí)，使用 auto_ptr 也可以完成對(duì)內(nèi)存資源的管理，但是因?yàn)?auto_ ptr 不夠安全，不提倡使用，即任何情況下都不應(yīng)該使用 auto_ptr。

（4）為了解決 shared_ptr 的循環(huán)引用問題，我們可以祭出 weak_ptr。

（5）在局部作用域（例如函數(shù)內(nèi)部或類內(nèi)部），且不需要將指針作為參數(shù)或返回值進(jìn)行傳遞的情況下，如果對(duì)性能要求嚴(yán)格，使用 scoped_ptr 的開銷較 shared_ptr 會(huì)小一些。

參考文獻(xiàn)

[1] Stanley B.Lippman著,王剛,楊巨峰譯.C++ Primer(第五版).2013.P400-422
[2] Scott Meyers著，侯捷譯.Effective C++中文版(第三版).2011.P61-7

C++智能指針shared_ptr分析

c++11 新特性——智能指針使用詳解

以上就是C++ STL 四種智能指針的用法詳解的詳細(xì)內(nèi)容，更多關(guān)于C++ 智能指針的資料請(qǐng)關(guān)注腳本之家其它相關(guān)文章！