最近接觸到智能指針很多，于是研究了一下智能指針的原理，寫下自己的心得體會，有不對的還請指正。

智能指針產生的目的：因為在C++中，存在非常復雜的指針錯誤問題，例如，某個對象生成后，指向該對象的指針可能有多個，當我們用delete語句刪除其中的一個指針后，對象就被銷毀，那么其余指向該對象的指針就會懸空，這樣很容易出錯內存誤，為避免出現這樣的問題，出現了智能指針，智能指針有2種構造方法，一種是插入式的還有一種是非插入式的，非插入式指針一般是直接采用裸指針作為參數進行創建，不需要修改現有的對象代碼，而插入式是采用一個公用的有數量統計功能的基類來派生需要智能指針的類，相對來說，插入式構造方法將需要更多的額外空間，而且需要修改原類。非插入式智能指針（shared_ptr）可以從裸指針，另一個shared_ptr、一個std::auto_ptr、或者一個boost::weak_ptr來構造，還可以傳遞第二個參數給shared_ptr的構造函數，它被稱為刪除器(deleter)。刪除器稍后會被調用，來處理共享資源的釋放。這對于管理那些不是用new分配也不是用delete釋放的資源時非常有用。shared_ptr被創建后，它就可象普通指針一樣使用了，除了一點，它不能被顯式地刪除，列舉一個shared_ptr的例子，有時候把對象直接存入容器中有時會有些麻煩,以值的方式保存對象意味著使用者將獲得容器中的元素的拷貝，對于那些復制是一種昂貴的操作的類型來說可能會有性能的問題。此外，有些容器，特別是 std::vector, 當你加入元素時可能會復制所有元素，這更加重了性能的問題。最后，傳值的語義意味著沒有多態的行為。如果你需要在容器中存放多態的對象而且你不想切割它們，你必須用指針。如果你用裸指針，維護元素的完整性會非常復雜。從容器中刪除元素時，你必須知道容器的使用者是否還在引用那些要刪除的元素，不用擔心多個使用者使用同一個元素。這些問題都可以用shared_ptr來解決。插入式版本。有時我們必須使用插入式的引用計數智能指針。典型的情況是對于那些已經寫好了內部引用計數器的代碼，而我們又沒有時間去重寫它(或者已經不能獲得那些代碼了)。另一種情況是要求智能指針的大小必須與裸指針大小嚴格相等，或者shared_ptr的引用計數器分配嚴重影響了程序的性能(這是非常罕見的情況！)。從功能的觀點來看，唯一需要插入式智能指針的情況是，被指類的某個成員函數需要返回this，以便它可以用于另一個智能指針(事實上，也有辦法使用非插入式智能指針來解決這個問題)。intrusive_ptr 不同于其它智能指針，因為它要求你來提供它所要的引用計數器。當 intrusive_ptr 遞增或遞減一個非空指針上的引用計數時，它是通過分別調用函數 intrusive_ptr_add_ref 和 intrusive_ptr_release來完成的。這兩個函數負責確保引用計數的正確性，并且負責在引用計數降為零時刪除指針。因此，你必須為你的類重載這兩個函數。

?

?

下面是部分實現源代碼：

非插入式版本：

namespace boost {
template<typename T> class shared_ptr {
public:
template <class Y> explicit shared_ptr(Y* p); //從裸露指針構造
template <class Y,class D> shared_ptr(Y* p,D d); //從裸露指針構造,同時指定刪除器
~shared_ptr();
shared_ptr(const shared_ptr & r); //從另一個指針指針構造template <class Y> explicit shared_ptr(const weak_ptr<Y>& r);//從弱指針構造
template <class Y> explicit shared_ptr(std::auto_ptr<Y>& r);//從自動指針構造
shared_ptr& operator=(const shared_ptr& r); void reset();//用于停止對保存指針的所有權的共享。共享資源的引用計數減一
T& operator*() const;
T* operator->() const;
T* get() const;
bool unique() const;
long use_count() const;
operator unspecified_bool_type() const;?
void swap(shared_ptr<T>& b);
};
template <class T,class U>
shared_ptr<T> static_pointer_cast(const shared_ptr<U>& r);
} ?

插入式版本（只列出了最重要的函數）

namespace boost {
? template<class T> class intrusive_ptr {
? public:
??? intrusive_ptr(T* p,bool add_ref=true);
??? intrusive_ptr(const intrusive_ptr& r);
??? ~intrusive_ptr();
??? T& operator*() const;
??? T* operator->() const;
??? T* get() const;
??? operator unspecified-bool-type() const;
? };
? template <class T> T* get_pointer(const intrusive_ptr<T>& p);
? template <class T,class U> intrusive_ptr<T>
? static_pointer_cast(const intrusive_ptr<U>& r);

使用intrusive_ptr與使用shared_ptr相比，有兩個主要的不同之處。第一個是你需要提供引用計數的機制。第二個是把this當成智能指針是合法的^[12]，正如我們即將看到的，有時候這樣很方便。注意，在多數情況下，應該使用非插入式的 shared_ptr. 你不能用shared_ptr 來做到這一點，如果沒有進行特殊處理的話，如 enable_shared_from_this.要使用 boost::intrusive_ptr, 要包含 "boost/intrusive_ptr.hpp" 并定義兩個普通函數 intrusive_ptr_add_ref 和 intrusive_ptr_release. 它們都要接受一個參數，即指向你要使用intrusive_ptr的類型的指針。這兩個函數的返回值被忽略。通常的做法是，泛化這兩個函數，簡單地調用被管理類型的成員函數去完成工作(例如，調用 add_ref 和 release)。如果引用計數降為零，intrusive_ptr_release 應該負責釋放資源。以下是你應該如何實現這兩個泛型函數的示范：

template <typename T> void intrusive_ptr_add_ref(T* t) {
? t->add_ref();
}

template <typename T> void intrusive_ptr_release(T* t) {
? if (t->release()<=0)
??? delete t;
}

注意，這兩個函數應該定義在它們的參數類型所在的作用域內。這意味著如果這個函數接受的參數類型來自于一個名字空間，則函數也必須定義在那里。這樣做的原因是，函數的調用是非受限的，即允許采用參數相關查找，而如果有多個版本的函數被提供，那么全部名字空間肯定不是放置它們的好地方。我們稍后將看到一個關于如何放置它們的例子，但首先，我們需要提供某類的引用計數器。

?

explicit關鍵字: c++中的explicit關鍵字用來修飾類的構造函數，表明該構造函數是顯式的，既然有"顯式"那么必然就有"隱式"，那么什么是顯示而什么又是隱式的呢？如果c++類的構造函數有一個參數，那么在編譯的時候就會有一個缺省的轉換操作：將該構造函數對應數據類型的數據轉換為該類對象，如下面所示：
class MyClass
{
public:
MyClass( int num );
}
....
MyClass obj = 10; //ok,convert int to MyClass
在上面的代碼中編譯器自動將整型轉換為MyClass類對象，實際上等同于下面的操作：
MyClass temp(10);
MyClass obj = temp;
上面的所有的操作即是所謂的"隱式轉換"。 未完待續。。。。。

?

總結

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

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