這篇文章主要介紹 boost中的智能指針的使用。

??? 內存管理是一個比較繁瑣的問題，C++中有兩個實現方案： 垃圾回收機制和智能指針。垃圾回收機制因為性能等原因不被C++的大佬們推崇， 而智能指針被認為是解決C++內存問題的最優方案。

1. 定義

???? 一個智能指針就是一個C++的對象， 這對象的行為像一個指針，但是它卻可以在其不需要的時候自動刪除。注意這個“其不需要的時候”， 這可不是一個精確的定義。這個不需要的時候可以指好多方面：局部變量退出函數作用域、類的對象被析構……。所以boost定義了多個不同的智能指針來管理不同的場景。

shared_ptr<T>	內部維護一個引用計數器來判斷此指針是不是需要被釋放。是boost中最常用的智能指針了。
scoped_ptr<t>	當這個指針的作用域消失之后自動釋放
intrusive_ptr<T>	也維護一個引用計數器，比shared_ptr有更好的性能。但是要求T自己提供這個計數器。
weak_ptr<T>	弱指針，要和shared_ptr 結合使用
shared_array<T>	和shared_ptr相似，但是訪問的是數組
scoped_array<T>	和scoped_ptr相似，但是訪問的是數組

2. Boost::scoped_ptr<T>

??? scoped_ptr 是boost中最簡單的智能指針。scoped_ptr的目的也是很簡單， 當一個指針離開其作用域時候，釋放相關資源。特別注意的一定就是scoped_ptr 不能共享指針的所有權也不能轉移所有權。也就是說這個內存地址就只能給的聲明的變量用，不能給其他使用。

??? 下面是scoped_ptr的幾個特點：

scoped_ptr的效率和空間的消耗內置的指針差不多。

scoped_ptr不能用在標準庫的容器上。(用shared_ptr代替)

scoped_ptr 不能指向一塊能夠動態增長的內存區域(用scoped_array代替)

1 class test
2 {
3 public:
4 void print()
5 {
6 cout << "test print now" <<endl;
7 }
8 };
9 int _tmain(int argc, _TCHAR* argv[])
10 {
11 boost::scoped_ptr<test> x(new test);
12 x->print();
13 return 0;
14 }

3.Boost::shared_ptr<T>

??? shared_ptr 具有如下幾個特點：

在內部維護一個引用計數器， 當有一個指針指向這塊內存區域是引用計數+1， 反之-1， 如果沒有任何指針指向這塊區域， 引用計數器為0，釋放內存區域。

可以共享和轉移所有權。

可以被標準庫的容器所使用

不能指向一塊動態增長的內存(用share_array代替)

我們可以看下如下例子：

1 int _tmain(int argc, _TCHAR* argv[])
2 {
3 boost::shared_ptr<test> ptr_1(new test);
4 ptr_1->print();//引用計數為1
5 boost::shared_ptr<test> ptr_2 = ptr_1;
6 ptr_2->print();//引用計數為2
7 ptr_1->print();// 引用計數還是為2
8 return 0;
9 }

4. Boost::intrusive_ptr<T>

??? intrusive_ptr 的主要和share_ptr一樣， 對比share_ptr,其效率更高，但是需要自己維護一個引用計數器。

shared_ptr比普通指針提供了更完善的功能。有一個小小的代價，那就是一個共享指針比普通指針占用更多的空間，每一個對象都有一個共享指針，這個指針有引用計數器以便于釋放。但對于大多數實際情況，這些都是可以忽略不計的。intrusive_ptr 提供了一個折中的解決方案。它提供了一個輕量級的引用計數器，但必須對象本身已經有了一個對象引用計數器。這并不是壞的想法，當你自己的設計的類中實現智能指針相同的工作，那么一定已經定義了一個引用計數器，這樣只需要更少的內存，而且可以提高執行性能。如果你要使用intrusive_ptr 指向類型T，那么你就需要定義兩個函數：intrusive_ptr_add_ref 和intrusive_ptr_release。下面是一個簡單的例子解釋如何在自己的類中實現：

#include "boost/intrusive_ptr.hpp"// forward declarations class CRefCounted; namespace boost {void intrusive_ptr_add_ref(CRefCounted * p);void intrusive_ptr_release(CRefCounted * p); };// My Class class CRefCounted {private:long references;friend void ::boost::intrusive_ptr_add_ref(CRefCounted * p);friend void ::boost::intrusive_ptr_release(CRefCounted * p);public:CRefCounted() : references(0) {} // initialize references to 0 }; // class specific addref/release implementation // the two function overloads must be in the boost namespace on most compilers: namespace boost {inline void intrusive_ptr_add_ref(CRefCounted * p){// increment reference count of object *p++(p->references);}inline void intrusive_ptr_release(CRefCounted * p){// decrement reference count, and delete object when reference count reaches 0if (--(p->references) == 0)delete p;} } // namespace boost

?這是一個最簡單的（非線程安全）實現操作。但作為一種通用的操作，如果提供一種基類來完成這種操作或許很有使用價值，也許在其他地方會介紹到。????????

5. Boost::weak_ptr<T>

????

強引用和弱引用的比較：

一個強引用當被引用的對象活著的話，這個引用也存在（就是說，當至少有一個強引用，那么這個對象就不能被釋放）。boost::share_ptr就是強引用。相對而言，弱引用當引用的對象活著的時候不一定存在。僅僅是當它存在的時候的一個引用。

boost::weak_ptr<T> 是執行弱引用的智能指針。當你需要它的時候就可以使用一個強（共享）指針指向它（當對象被釋放的時候，它為空），當然這個強指針在使用完畢應該立即釋放掉，在上面的例子中我們能夠修改它為弱指針。

struct CBetterChild : public CSample {weak_ptr<CDad> myDad;void BringBeer(){shared_ptr<CDad> strongDad = myDad.lock(); // request a strong pointerif (strongDad) // is the object still alive?strongDad->SetBeer();// strongDad is released when it goes out of scope.// the object retains the weak pointer} };

? ? weak_ptr 就是一個弱指針。weak_ptr 被shared_ptr控制， 它可以通過share_ptr的構造函數或者lock成員函數轉化為share_ptr。

??? weak_ptr的一個最大特點就是它共享一個share_ptr的內存，但是無論是構造還是析構一個weak_ptr 都不會影響引用計數器。

1 int _tmain(int argc, _TCHAR* argv[])
2 {
3 boost::shared_ptr<test> sharePtr(new test);;
4 boost::weak_ptr<test> weakPtr(sharePtr);
5 //weakPtr 就是用來保存指向這塊內存區域的指針的
6 //干了一大堆其他事情
7 boost::shared_ptr<test> sharePtr_2 = weakPtr.lock();
8 if (sharePtr_2)
9 sharePtr_2->print();
10 return 0;
11 }

6. Boost::shared_array<T> 和Boost::scoped_array<T>

??? 前面提到過shared_ptr和scoped_ptr不能用于數組的內存（new []），所以shared_array和scoped_array就是他們的代替品。我們可以看下shared_array的用法

1 int _tmain(int argc, _TCHAR* argv[])
2 {
3 const int size = 10;
4 boost::shared_array<test> a(new test[]);
5 for (int i = 0; i < size; ++i)
6 a[i].print();
7 return 0;
8 }

7. 使用智能指針的幾個注意點

??? 下面是幾個使用智能指針需要注意的地方：

聲明一個智能指針的時候要立即給它實例化， 而且一定不能手動釋放它。

…_ptr<T> 不是T* 類型。所以：

??????????????? a: 聲明的時候要…_ptr<T> 而不是….._ptr<T*>

??????????????? b：不能把T* 型的指針賦值給它

??????????????? c: 不能寫ptr=NULl, 而用ptr.reset()代替。

不能循環引用。

不要聲明臨時的share_ptr， 然后把這個指針傳遞給一個函數

8. 總結

??? 智能指針使用上還是比較簡單的， 而且能比較有效得解決C++內存泄露的問題，各位使用C++的童鞋趕快用起來吧。

總結

以上是生活随笔為你收集整理的【Boost】boost库中智能指针概述的全部內容，希望文章能夠幫你解決所遇到的問題。

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