作者 主題: boost 智慧型指標 shared_ptr  (閱讀 4515 次)

0 會員 與 1 訪客 正在閱讀本文。

FIEND

  • 鑽研的研究生
  • *****
  • 文章數: 700
    • 檢視個人資料
    • http://bbs.ecstart.com
boost 智慧型指標 shared_ptr
« 於: 2012-09-05 23:41 »

http://www.boost.org/doc/libs/1_51_0/libs/smart_ptr/smart_ptr.htm


http://67.223.234.84/boost_doc/libs/smart_ptr/shared_ptr.htm


Introduction 簡介

shared_ptr 類模板存儲一個指向動態分配對像(一般是用 C++ new-expression 生成的)的指針。在最後一個 shared_ptr 所指向的對象被銷毀或重置時,要保證它所指向的對象被刪除。參見示例。

每一個 shared_ptr 都符合 C++ 標準庫的 CopyConstructible 和 Assignable 的必要條件,並因此能夠用於標準庫容器。因為提供了比較操作,因此 shared_ptr 可以和標準庫中的關聯式容器一起工作。

通常,一個 shared_ptr 不能正確地持有一個指向動態分配的數組的指針。關於那種用法請參見 shared_array。

因為在實現中使用了引用計數,shared_ptr實例的循環引用不會被回收。例如,如果 main() 持有一個指向 A 的 shared_ptr, A 又直接或間接持有一個指回 A 的 shared_ptr,A 的使用計數是 2。最初的 shared_ptr 析構後將導致一個使用計數為 1 的 A 被懸掛。使用 weak_ptr 以「打破循環」。

這個類模板被 T 參數化,T 是被指向的對象的類型。shared_ptr 和它的大多數成員函數對於 T 沒什麼要求,允許它是一個不完整類型,或者為 void。對 T 有附加要求的成員函數 (constructors, reset) 都明確地記錄在下面。

只要 T* 能被隱式地轉換到 U*,則 shared_ptr<T> 就能被隱式地轉換到 shared_ptr<U>。特別是,shared_ptr<T> 隱式轉換到 shared_ptr<T const>,當 U 是 T 的一個可訪問基類的時候,還能轉換到 shared_ptr<U>,以及轉換到 shared_ptr<void>。

shared_ptr 現在是 TR1(第一個 C++ 庫技術報告)的一部分。TR1 的最新草案可以在下述位置找到:

http://www.open-std.org/JTC1/SC22/WG21/docs/papers/2005/n1745.pdf (1.36Mb PDF)

這個實現與 TR1 規範一致,僅有的例外是它依然存在於名字空間 boost 中,而不是 std::tr1。
Best Practices 最佳實踐

一個簡單的近乎完全消滅內存洩露的方針是:總是使用一個已命名的智能指針變量接收 new 的結果。代碼中每一次出現 new 關鍵字都應該是如下形式:

shared_ptr<T> p(new Y);

當然,也可以用其它智能指針代替上面的 shared_ptr;T 是和 Y 相同的類型,或者是可作為參數傳遞給 Y 的構造函數即可。

如果你遵守這個方針,自然導致你不再需要顯式 deletes,try/catch 結構也將非常罕見。

避免使用匿名 shared_ptr 臨時變量去存儲內容,為了看到這樣做是如何的危險,請考慮下面的例子:

void f(shared_ptr<int>, int);
int g();

void ok()
{
    shared_ptr<int> p(new int(2));
    f(p, g());
}

void bad()
{
    f(shared_ptr<int>(new int(2)), g());
}

函數 ok 亦步亦趨地遵循了方針,相反 bad 構造了臨時的 shared_ptr 來代替,這就為內存洩漏留下了可乘之機。因為函數參數的求值順序是不確定的,new int(2) 首先被求值,g() 第二個是有可能的,如果 g 拋出一個異常,我們永遠也不可能到達 shared_ptr 的構造函數。關於這個問題的更多信息請參見 Herb Sutter 的對策(還有 這裡)。
Synopsis 概要

namespace boost {

  class bad_weak_ptr: public std::exception;

  template<class T> class weak_ptr;

  template<class T> class shared_ptr {

    public:

      typedef T element_type;

      shared_ptr(); // never throws
      template<class Y> explicit shared_ptr(Y * p);
      template<class Y, class D> shared_ptr(Y * p, D d);
      template<class Y, class D, class A> shared_ptr(Y * p, D d, A a);
      ~shared_ptr(); // never throws

      shared_ptr(shared_ptr const & r); // never throws
      template<class Y> shared_ptr(shared_ptr<Y> const & r); // never throws
      template<class Y> explicit shared_ptr(weak_ptr<Y> const & r);
      template<class Y> explicit shared_ptr(std::auto_ptr<Y> & r);

      shared_ptr & operator=(shared_ptr const & r); // never throws 
      template<class Y> shared_ptr & operator=(shared_ptr<Y> const & r); // never throws
      template<class Y> shared_ptr & operator=(std::auto_ptr<Y> & r);

      void reset(); // never throws
      template<class Y> void reset(Y * p);
      template<class Y, class D> void reset(Y * p, D d);
      template<class Y, class D, class A> void reset(Y * p, D d, A a);
      template<class Y> void reset(shared_ptr<Y> const & r, T * p); // never throws

      T & operator*() const; // never throws
      T * operator->() const; // never throws
      T * get() const; // never throws

      bool unique() const; // never throws
      long use_count() const; // never throws

      operator unspecified-bool-type() const; // never throws

      void swap(shared_ptr & b); // never throws
  };

  template<class T, class U>
    bool operator==(shared_ptr<T> const & a, shared_ptr<U> const & b); // never throws

  template<class T, class U>
    bool operator!=(shared_ptr<T> const & a, shared_ptr<U> const & b); // never throws

  template<class T, class U>
    bool operator<(shared_ptr<T> const & a, shared_ptr<U> const & b); // never throws

  template<class T> void swap(shared_ptr<T> & a, shared_ptr<T> & b); // never throws

  template<class T> T * get_pointer(shared_ptr<T> const & p); // never throws

  template<class T, class U>
    shared_ptr<T> static_pointer_cast(shared_ptr<U> const & r); // never throws

  template<class T, class U>
    shared_ptr<T> const_pointer_cast(shared_ptr<U> const & r); // never throws

  template<class T, class U>
    shared_ptr<T> dynamic_pointer_cast(shared_ptr<U> const & r); // never throws

  template<class E, class T, class Y>
    std::basic_ostream<E, T> & operator<< (std::basic_ostream<E, T> & os, shared_ptr<Y> const & p);

  template<class D, class T>
    D * get_deleter(shared_ptr<T> const & p);
}

Members 成員
element_type 元素類型

typedef T element_type;

    提供模板參數 T 的類型。

constructors 構造函數

shared_ptr(); // never throws

    作用:構造一個 empty 的 shared_ptr。

    後置條件:use_count() == 0 && get() == 0。

    拋出:無。

【這裡保證不拋出異常非常重要,因為 reset() 被指定使用缺省構造函數,這就意味著構造函數不必分配內存。】

template<class Y> explicit shared_ptr(Y * p);

    條件:p 必須可以被轉換到 T *。Y 必須是一個完整類型。表達式 delete p 必須是正常可用的,不能發生未定義行為,也不能拋出異常。

    作用:構造一個擁有指針 p 的 shared_ptr。

    後置條件:use_count() == 1 && get() == p。

    拋出:std::bad_alloc,或者一個由實現定義的當內存之外的某個資源無法獲得時的異常。

    異常安全:如果拋出一個異常,則調用 delete p。

    注意:p 必須是一個指向由 C++ new 表達式分配的對象的指針或者是 0。即使 p 是 0,後置條件中的 use count 也是 1,在一個值為 0 的指針上調用 delete 是無害的。

【這個構造函數被變成模板是為了記住被傳遞的實際的指針類型。析構函數可以針對同樣的指針,連同它的原始類型調用 delete,即使 T 沒有虛擬析構函數,或者是 void。

可選的侵入式的計數支持暴露了太多的實現細節,而且無法和 weak_ptr 很好地結合。當前實現使用了一個不同的機制,enable_shared_from_this 以解決 "shared_ptr from this" 問題。】

template<class Y, class D> shared_ptr(Y * p, D d);
template<class Y, class D, class A> shared_ptr(Y * p, D d, A a);

    條件:p 必須可變換為 T *。D 必須是 CopyConstructible(可拷貝構造)的。D 的拷貝構造函數和析構函數不能拋出異常。表達式 d(p) 必須是正常可用的,不能發生未定義行為,也不能拋出異常。A 必須是一個 Allocator(分配器),關於分配器的描述可參見 C++ 標準 20.1.5 (Allocator requirements)。

    作用:構造一個擁有指針 p 和刪除器 d 的 shared_ptr。第二個構造函數用 a 的一個拷貝分配內存。

    後置條件:use_count() == 1 && get() == p。

    拋出:std::bad_alloc,或者一個由實現定義的當內存之外的某個資源無法獲得時的異常。

    異常安全:如果拋出一個異常,則調用 d(p)。

    注意:在 p 指向的對象被刪除時,所存儲的 d 的拷貝被調用,並以所存儲的 p 的拷貝作為參數。

【custom deallocators(定制化釋放器)准許一個返回 shared_ptr 的工廠函數以將用戶隔離在它的內存分配策略之外。因為這個 deallocator(釋放器)不是類型的一部分,改變其分配策略不會破壞源代碼級或二進制級兼容性,也不需要客戶端重新編譯。例如,一個 "no-op" 釋放器返回一個指向靜態分配對象的 shared_ptr 是有用的,而其它變種卻允許用一個 shared_ptr 來包裝其它智能指針,以方便互操作性。

對 custom deallocators(定制化釋放器)的支持不會強加很大的負擔。其它 shared_ptr 特性依然需要 deallocator(釋放器)提供支持。

對 D 的拷貝構造函數不能拋出異常的需求來自於以值傳遞。如果拷貝構造函數拋出異常,指針就會洩漏。排除這一需求需要使用以 (const) reference((常)引用)傳遞。

以引用傳遞的主要問題在於它和 rvalues(右值)的相互影響。一個 const reference(常引用)可能還是會引起一次拷貝,並需要一個 const operator()。而一個 non-const reference(非常引用)根本不會綁定在一個右值上。解決這個問題的一個好的方案是 N1377/N1385 提案中的 rvalue reference(右值引用)。】

shared_ptr(shared_ptr const & r); // never throws
template<class Y> shared_ptr(shared_ptr<Y> const & r); // never throws

    作用:如果 r 為 empty,構造一個 empty shared_ptr,否則,構造一個帶有 r 的 shares ownership(共享所有權)的 shared_ptr。

    後置條件: get() == r.get() && use_count() == r.use_count()。

    拋出:無。

template<class Y> explicit shared_ptr(weak_ptr<Y> const & r);

    作用:構造一個帶有 r 的 shares ownership(共享所有權)的 shared_ptr,並存儲 r 中所存儲指針的一個拷貝。

    後置條件:use_count() == r.use_count()。

    拋出:當 r.use_count() == 0 時,拋出 bad_weak_ptr。

    異常安全:如果拋出一個異常,構造函數將不起作用。

template<class Y> shared_ptr(std::auto_ptr<Y> & r);

    作用:構造一個 shared_ptr,就像存儲了一個 r.release() 的返回值的拷貝。

    後置條件:use_count() == 1。

    拋出:std::bad_alloc,或者一個由實現定義的當內存之外的某個資源無法獲得時的異常。

    異常安全:如果拋出一個異常,構造函數將不起作用。

【這個構造函數所得到的源 auto_ptr 是以引用傳遞的,而非以值傳遞,而且不能接收 auto_ptr 臨時變量。這是故意的,作為構造函數提出的強制保證,一個右值引用也可以解決這個問題。】
destructor 析構函數

~shared_ptr(); // never throws

    作用:

        如果 *this 為 empty,或者和其他 shared_ptr 實例共享所有權 (use_count() > 1),沒有副作用。
        否則,如果 *this 擁有一個指針 p 和一個刪除器 d,則調用 d(p)。
        否則,*this 擁有一個指針 p,則調用 delete p。

    拋出:無。

assignment 賦值

shared_ptr & operator=(shared_ptr const & r); // never throws
template<class Y> shared_ptr & operator=(shared_ptr<Y> const & r); // never throws
template<class Y> shared_ptr & operator=(std::auto_ptr<Y> & r);

    作用:等價於 shared_ptr(r).swap(*this)。

    返回:*this。

    注意:由臨時對象的構造和析構造成的使用計數的更新不被認為是可察覺的副作用,而實現可以自由地經由不同的手段達到其效果(以及隱含的保證),而不創建臨時變量。特別是,在下例中:

    shared_ptr<int> p(new int);
    shared_ptr<void> q(p);
    p = p;
    q = p;

    兩個賦值可能都是 no-op(什麼都不做)。

reset 重置

void reset(); // never throws

    作用:等價於 shared_ptr().swap(*this)。

template<class Y> void reset(Y * p);

    作用:等價於 shared_ptr(p).swap(*this)。

template<class Y, class D> void reset(Y * p, D d);

    作用:等價於 shared_ptr(p, d).swap(*this)。

template<class Y, class D, class A> void reset(Y * p, D d, A a);

    作用:等價於 shared_ptr(p, d, a).swap(*this)。

template<class Y> void reset(shared_ptr<Y> const & r, T * p); // 不拋出

    作用:等價於 shared_ptr(r, p).swap(*this).

indirection 間接引用

T & operator*() const; // never throws

    條件:所存儲的指針不能為 0。

    返回:一個引向所存儲的指針所指向的對象的引用。

    拋出:無。

T * operator->() const; // never throws

    條件:所存儲的指針不能為 0。

    返回:所存儲的指針。

    拋出:無。

get 取得

T * get() const; // never throws

    返回:所存儲的指針。

    拋出:無。

unique 唯一性

bool unique() const; // never throws

    返回:use_count() == 1。

    拋出:無。

    注意:unique() 可能比 use_count() 更快。如果你用 unique() 實現 copy on write(寫時拷貝),當所存儲的指針為 0 是,不要依賴於一個特定的值。

use_count 使用計數

long use_count() const; // never throws

    返回:與 *this 共享所有權的 shared_ptr 對像(包括 *this 在內)的數量,或者當 *this 為空時,一個不特定的非負值。

    拋出:無。

    注意:use_count() 達不到必要的效率。只用於調試和測試的目的。而不要用於產品代碼。

conversions 轉換

operator unspecified-bool-type () const; // never throws

    返回:一個未確定的值,在需要布爾值的上下文中,它等價於 get() != 0。

    拋出:無。

    注意:這一轉換操作符允許將 shared_ptr 對像用於需要布爾值的上下文中,就像 if (p && p->valid()) {}。實際目標類型通常是一個指向成員函數的指針,消除了很多隱式轉換的陷阱。

【到 bool 的轉換不僅僅是語法糖。它允許在使用 dynamic_pointer_cast 或 weak_ptr::lock 時,在條件中聲明 shared_ptrs。】
swap 交換

void swap(shared_ptr & b); // never throws

    作用:交換兩個智能指針中的內容。

    拋出:無。

Free Functions 自由函數
comparison 比較

template<class T, class U>
  bool operator==(shared_ptr<T> const & a, shared_ptr<U> const & b); // never throws

    返回:a.get() == b.get()。

    拋出:無。

template<class T, class U>
  bool operator!=(shared_ptr<T> const & a, shared_ptr<U> const & b); // never throws

    返回:a.get() != b.get()。

    拋出:無。

template<class T, class U>
  bool operator<(shared_ptr<T> const & a, shared_ptr<U> const & b); // never throws

    返回:一個未確定值,以致於

        operator< 是一個嚴格意義上的 C++ 標準 25.3 [lib.alg.sorting] 中描述的 weak ordering(弱順序);
        等值關係通過 operator< 來定義,!(a < b) && !(b < a),在這種情況下,當且僅當兩個 shared_ptr 實例共享所有權或者都為空時,兩個 shared_ptr 相等。

    拋出:無。

    注意:允許 shared_ptr 對像在關聯式容器中作為鍵值使用。

【因為兼容性和合法性的原因,Operator< 比 std::less 的特化版本更優先被選用,因為 std::less 需要返回一個 operator< 的結果,而當沒有提供謂詞時,許多標準算法在比較中使用 operator< 來代替 std::less。組合對象,比如 std::pair,也根據它們所包含的子對象的 operator< 來實現它們的 operator<。

其餘的比較操作符被故意省略。】
swap 交換

template<class T>
  void swap(shared_ptr<T> & a, shared_ptr<T> & b); // never throws

    作用:等價於 a.swap(b)。

    拋出:無。

    注意:與 std::swap 的接口匹配。為泛型編程提供幫助。

【swap 被定義在和 shared_ptr 同樣的名字空間中,這是當前提供一個讓標準庫有機會使用的 swap 函數的僅有的合法方法。】
get_pointer 取得指針

template<class T>
  T * get_pointer(shared_ptr<T> const & p); // never throws

    返回:p.get()。

    拋出:無。

    注意:為泛型編程提供幫助,用於 mem_fn。

static_pointer_cast

template<class T, class U>
  shared_ptr<T> static_pointer_cast(shared_ptr<U> const & r); // never throws

    條件:表達式 static_cast<T*>(r.get()) 必須正常可用。

    返回:如果 r 為 empty,返回一個 empty shared_ptr<T>;否則,返回一個存儲 static_cast<T*>(r.get()) 的拷貝並和 r 共享所有權的 shared_ptr<T> 對象。

    拋出:無。

    注意:表面上看似乎等價的表達式

    shared_ptr<T>(static_cast<T*>(r.get()))

    因為試圖刪除同樣的對象兩次,而最終陷入未定義行為。

const_pointer_cast

template<class T, class U>
  shared_ptr<T> const_pointer_cast(shared_ptr<U> const & r); // never throws

    條件:表達式 const_cast<T*>(r.get()) 必須正常可用。

    返回:如果 r 為 empty,返回一個 empty shared_ptr<T>;否則,返回一個存儲 const_cast<T*>(r.get()) 的拷貝並和 r 共享所有權的 shared_ptr<T> 對象。

    拋出:無。

    注意:表面上看似乎等價的表達式

    shared_ptr<T>(const_cast<T*>(r.get()))

    因為試圖刪除同樣的對象兩次,而最終陷入未定義行為。

dynamic_pointer_cast

template<class T, class U>
  shared_ptr<T> dynamic_pointer_cast(shared_ptr<U> const & r);

    條件:表達式 dynamic_cast<T*>(r.get()) 必須正常可用,而且它的行為已被定義。

    返回:

        當 dynamic_cast<T*>(r.get()) 返回一個非 0 值,則返回一個存儲它的拷貝並和 r 共享所有權的 shared_ptr<T> 對像;
        否則,返回一個 empty shared_ptr<T> 對象。

    拋出:無。

    注意:表面上看似乎等價的表達式

    shared_ptr<T>(dynamic_cast<T*>(r.get()))

    因為試圖刪除同樣的對象兩次,而最終陷入未定義行為。

operator<<

template<class E, class T, class Y>
    std::basic_ostream<E, T> & operator<< (std::basic_ostream<E, T> & os, shared_ptr<Y> const & p);

    作用:os << p.get();。

    返回:os。

get_deleter

template<class D, class T>
    D * get_deleter(shared_ptr<T> const & p);

    返回:如果 *this 擁有一個類型為 D 的刪除器 d,則返回 &d;否則返回 0。

Example 示例

來看一個完整的示例程序 shared_ptr_example.cpp。這個程序創建了一個 shared_ptr 對象的 std::vector 和 std::set。

注意,在容器被填充之後,一些 shared_ptr 對象的使用計數為 1,而不是 2,這是因為 set 是一個 std::set 而不是 std::multiset,而這樣就不能包含重複的條目。此外,當 push_back 和 insert 容器操作執行的次數不同,使用計數可能會更高。還有更複雜的,容器操作在多種情況下都可能拋出異常。在這個示例程序中的內存管理和異常處理都很正常,而沒有讓智能指針成為一場噩夢。
Handle/Body Idiom Handle/Body 慣用法

shared_ptr 的一個慣常用法是實現 handle/body(也稱為 pimpl)慣用法,以避免在頭文件中暴露身體(實現)。

shared_ptr_example2_test.cpp 示例程序包含一個頭文件 shared_ptr_example2.hpp,其中使用了一個指向一個完整類型的 shared_ptr<> 來隱藏實現。成員函數的實例化要求在 shared_ptr_example2.cpp 實現文件中存在完整類型。注意這裡不需要顯示的析構函數。不像 ~scoped_ptr,~shared_ptr 不需要 T 是一個完整類型。
Thread Safety 線程安全

shared_ptr 對像提供與內建類型一樣的線程安全級別。一個 shared_ptr 實例可以同時被多個線程「讀」(僅使用不變操作進行訪問)。不同的 shared_ptr 實例可以同時被多個線程「寫入」(使用類似 operator= 或 reset 這樣的可變操作進行訪問)(即使這些實例是拷貝,而且共享下層的引用計數)。

任何其它的同時訪問的結果會導致未定義行為。

示例:

shared_ptr<int> p(new int(42));

//--- Example 1 ---

// thread A
shared_ptr<int> p2(p); // reads p

// thread B
shared_ptr<int> p3(p); // OK, multiple reads are safe

//--- Example 2 ---

// thread A
p.reset(new int(1912)); // writes p

// thread B
p2.reset(); // OK, writes p2

//--- Example 3 ---

// thread A
p = p3; // reads p3, writes p

// thread B
p3.reset(); // writes p3; undefined, simultaneous read/write

//--- Example 4 ---

// thread A
p3 = p2; // reads p2, writes p3

// thread B
// p2 goes out of scope: undefined, the destructor is considered a "write access"

//--- Example 5 ---

// thread A
p3.reset(new int(1));

// thread B
p3.reset(new int(2)); // undefined, multiple writes



從 Boost 版本 1.33.0 開始,shared_ptr 在以下平台上使用了 lock-free 實現:

    GNU GCC on x86 or x86-64;
    GNU GCC on IA64;
    Metrowerks CodeWarrior on PowerPC;
    GNU GCC on PowerPC;
    Windows.

如果你的程序是單線程的,而且在它的缺省配置中沒有連接任何可能使用了 shared_ptr 的庫,你可以在項目基準中 #define 宏 BOOST_SP_DISABLE_THREADS 以轉換到普通的非原子的引用計數更新。

(在部分(而非全部)編譯單元中定義 BOOST_SP_DISABLE_THREADS 在技術上是對單一定義規則和未定義行為的觸犯。然而,實現會盡其所能滿足那些提出使用非原子更新的編譯單元的要求。但是,沒有任何保證。)

你可以定義宏 BOOST_SP_USE_PTHREADS 以避開特定平台的 lock-free 實現,並退回到普通的基於 pthread_mutex_t 的代碼。
Frequently Asked Questions 常見問題

問:有幾種共享指針的變化,反映不同的權衡,為什麼智能指針庫僅提供一種單一的實現?能夠用每一種類型做試驗以發現最適合手邊工作的那一種不是非常有好處的嗎?

答:shared_ptr 的一個重要目標是提供一個標準的共享所有權指針。對於穩定的庫接口來說,單一指針類型是很重要的,因為不同的共享指針一般無法互操作,例如,一個 reference counted pointer(引用計數指針)(用於庫 A)不能和一個 linked pointer(連接指針)(用於庫 B)共享所有權。

問:shared_ptr 為什麼沒有用來提供特性或規則的模板參數以允許廣泛的用戶定制性?

答:參數化會阻礙用戶。shared_ptr 模板小心謹慎地精工細作以滿足通用需求,而沒有大量的參數化。有朝一日,可能會有人發明可配置性很高的智能指針,而且很易於使用並難於犯錯。到那時,shared_ptr 會成為為各種各樣的應用而選擇的智能指針。(那些對基於策略的智能指針感興趣的人可以閱讀 Andrei Alexandrescu 寫的 Modern C++ Design。)

問:我不確定。缺省參數可以用於那些需要隱藏複雜度的地方。再問一次,為什麼不規則化?

答:模板參數影響類型。參見上面第一個問題的回答。

問:shared_ptr 為什麼不用鏈表實現?

答:鏈表實現的好處不足以抵消一個額外的指針所增加的開銷。參見 timings 頁面。另外,讓一個鏈表實現線程安全的代價太大了。

問:shared_ptr(或其它任何一個 Boost 智能指針)不提供一個到 T* 的自動轉換?

答:自動轉換被認為更易於導致錯誤。

問:shared_ptr 為什麼提供 use_count()?

答:為了幫助寫測試用例和調試顯示。一個祖先類有 use_count(),它對於在一個複雜的項目中追蹤 bugs 並切斷循環依賴是非常有用的。

問:為什麼 shared_ptr 不指定複雜度要求?

答:因為複雜度要求限制了實現,並且使規範更複雜,對於 shared_ptr 的用戶卻沒有明顯的好處。例如,如果不得不符合嚴厲的複雜度要求,錯誤檢查的實現可能會變得不一致。

問:為什麼 shared_ptr 不提供一個 release() 函數?

答:shared_ptr 不能放棄所有權除非它是 unique(),因為其它拷貝仍然可以銷毀這個對象。

考慮:

    shared_ptr<int> a(new int);
    shared_ptr<int> b(a); // a.use_count() == b.use_count() == 2

    int * p = a.release();

    // Who owns p now? b will still call delete on it in its destructor.

此外,當源 shared_ptr 可能帶有一個定制化的刪除器時,release() 返回的指針很難可靠地被釋放。

問:為什麼 operator->() 是 const 的,而它的返回值卻是指向元素類型的 non-const 指針?

答:淺拷貝指針,包括裸指針,一般不會傳遞常量性。當你能夠總是從一個 const 指針得到一個 non-const 指針,並繼而通過它改變那個對象的時候,還是有一點兒意義的。shared_ptr 是「盡可能接近而不重合裸指針」。
« 上次編輯: 2012-09-06 00:06 由 FIEND »
你累了嗎? 這樣不行 , 人要比 LINUX 兇 @@ " ......

FIEND

  • 鑽研的研究生
  • *****
  • 文章數: 700
    • 檢視個人資料
    • http://bbs.ecstart.com
Re: boost 智慧型指標 shared_ptr
« 回覆 #1 於: 2012-09-05 23:46 »
shared_ptr.hpp , Version 1.51

#ifndef BOOST_SMART_PTR_SHARED_PTR_HPP_INCLUDED
#define BOOST_SMART_PTR_SHARED_PTR_HPP_INCLUDED

//
//  shared_ptr.hpp
//
//  (C) Copyright Greg Colvin and Beman Dawes 1998, 1999.
//  Copyright (c) 2001-2008 Peter Dimov
//
//  Distributed under the Boost Software License, Version 1.0. (See
//  accompanying file LICENSE_1_0.txt or copy at
//  http://www.boost.org/LICENSE_1_0.txt)
//
//  See http://www.boost.org/libs/smart_ptr/shared_ptr.htm for documentation.
//

#include <boost/config.hpp>   // for broken compiler workarounds

#if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES)
#include <boost/smart_ptr/detail/shared_ptr_nmt.hpp>
#else

// In order to avoid circular dependencies with Boost.TR1
// we make sure that our include of <memory> doesn't try to
// pull in the TR1 headers: that's why we use this header
// rather than including <memory> directly:
#include <boost/config/no_tr1/memory.hpp>  // std::auto_ptr

#include <boost/assert.hpp>
#include <boost/checked_delete.hpp>
#include <boost/throw_exception.hpp>
#include <boost/smart_ptr/detail/shared_count.hpp>
#include <boost/detail/workaround.hpp>
#include <boost/smart_ptr/detail/sp_convertible.hpp>

#if !defined(BOOST_SP_NO_ATOMIC_ACCESS)
#include <boost/smart_ptr/detail/spinlock_pool.hpp>
#include <boost/memory_order.hpp>
#endif

#include <algorithm>            // for std::swap
#include <functional>           // for std::less
#include <typeinfo>             // for std::bad_cast
#include <cstddef>              // for std::size_t

#if !defined(BOOST_NO_IOSTREAM)
#if !defined(BOOST_NO_IOSFWD)
#include <iosfwd>               // for std::basic_ostream
#else
#include <ostream>
#endif
#endif


namespace boost
{

template<class T> class shared_ptr;
template<class T> class weak_ptr;
template<class T> class enable_shared_from_this;
template<class T> class enable_shared_from_this2;

namespace detail
{

struct static_cast_tag {};
struct const_cast_tag {};
struct dynamic_cast_tag {};
struct polymorphic_cast_tag {};

template<class T> struct shared_ptr_traits
{
    typedef T & reference;
};

template<> struct shared_ptr_traits<void>
{
    typedef void reference;
};

#if !defined(BOOST_NO_CV_VOID_SPECIALIZATIONS)

template<> struct shared_ptr_traits<void const>
{
    typedef void reference;
};

template<> struct shared_ptr_traits<void volatile>
{
    typedef void reference;
};

template<> struct shared_ptr_traits<void const volatile>
{
    typedef void reference;
};

#endif
// enable_shared_from_this support

template< class X, class Y, class T > inline void sp_enable_shared_from_this( boost::shared_ptr<X> const * ppx, Y const * py, boost::enable_shared_from_this< T > const * pe )
{
    if( pe != 0 )
    {
        pe->_internal_accept_owner( ppx, const_cast< Y* >( py ) );
    }
}

template< class X, class Y, class T > inline void sp_enable_shared_from_this( boost::shared_ptr<X> * ppx, Y const * py, boost::enable_shared_from_this2< T > const * pe )
{
    if( pe != 0 )
    {
        pe->_internal_accept_owner( ppx, const_cast< Y* >( py ) );
    }
}

#ifdef _MANAGED

// Avoid C4793, ... causes native code generation

struct sp_any_pointer
{
    template<class T> sp_any_pointer( T* ) {}
};

inline void sp_enable_shared_from_this( sp_any_pointer, sp_any_pointer, sp_any_pointer )
{
}

#else // _MANAGED

inline void sp_enable_shared_from_this( ... )
{
}

#endif // _MANAGED

#if !defined( BOOST_NO_SFINAE ) && !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION ) && !defined( BOOST_NO_AUTO_PTR )

// rvalue auto_ptr support based on a technique by Dave Abrahams

template< class T, class R > struct sp_enable_if_auto_ptr
{
};

template< class T, class R > struct sp_enable_if_auto_ptr< std::auto_ptr< T >, R >
{
    typedef R type;
};

#endif

} // namespace detail

//
//  shared_ptr
//
//  An enhanced relative of scoped_ptr with reference counted copy semantics.
//  The object pointed to is deleted when the last shared_ptr pointing to it
//  is destroyed or reset.
//

template<class T> class shared_ptr
{
private:

    // Borland 5.5.1 specific workaround
    typedef shared_ptr<T> this_type;

public:

    typedef T element_type;
    typedef T value_type;
    typedef T * pointer;
    typedef typename boost::detail::shared_ptr_traits<T>::reference reference;

    shared_ptr(): px(0), pn() // never throws in 1.30+
    {
    }

    template<class Y>
    explicit shared_ptr( Y * p ): px( p ), pn( p ) // Y must be complete
    {
        boost::detail::sp_enable_shared_from_this( this, p, p );
    }

    //
    // Requirements: D's copy constructor must not throw
    //
    // shared_ptr will release p by calling d(p)
    //

    template<class Y, class D> shared_ptr(Y * p, D d): px(p), pn(p, d)
    {
        boost::detail::sp_enable_shared_from_this( this, p, p );
    }

    // As above, but with allocator. A's copy constructor shall not throw.

    template<class Y, class D, class A> shared_ptr( Y * p, D d, A a ): px( p ), pn( p, d, a )
    {
        boost::detail::sp_enable_shared_from_this( this, p, p );
    }

//  generated copy constructor, destructor are fine...

#if defined( BOOST_HAS_RVALUE_REFS )

// ... except in C++0x, move disables the implicit copy

    shared_ptr( shared_ptr const & r ): px( r.px ), pn( r.pn ) // never throws
    {
    }

#endif

    template<class Y>
    explicit shared_ptr(weak_ptr<Y> const & r): pn(r.pn) // may throw
    {
        // it is now safe to copy r.px, as pn(r.pn) did not throw
        px = r.px;
    }

    template<class Y>
    shared_ptr( weak_ptr<Y> const & r, boost::detail::sp_nothrow_tag ): px( 0 ), pn( r.pn, boost::detail::sp_nothrow_tag() ) // never throws
    {
        if( !pn.empty() )
        {
            px = r.px;
        }
    }

    template<class Y>
#if !defined( BOOST_SP_NO_SP_CONVERTIBLE )

    shared_ptr( shared_ptr<Y> const & r, typename boost::detail::sp_enable_if_convertible<Y,T>::type = boost::detail::sp_empty() )

#else

    shared_ptr( shared_ptr<Y> const & r )

#endif
    : px( r.px ), pn( r.pn ) // never throws
    {
    }

    // aliasing
    template< class Y >
    shared_ptr( shared_ptr<Y> const & r, T * p ): px( p ), pn( r.pn ) // never throws
    {
    }

    template<class Y>
    shared_ptr(shared_ptr<Y> const & r, boost::detail::static_cast_tag): px(static_cast<element_type *>(r.px)), pn(r.pn)
    {
    }

    template<class Y>
    shared_ptr(shared_ptr<Y> const & r, boost::detail::const_cast_tag): px(const_cast<element_type *>(r.px)), pn(r.pn)
    {
    }

    template<class Y>
    shared_ptr(shared_ptr<Y> const & r, boost::detail::dynamic_cast_tag): px(dynamic_cast<element_type *>(r.px)), pn(r.pn)
    {
        if(px == 0) // need to allocate new counter -- the cast failed
        {
            pn = boost::detail::shared_count();
        }
    }
    template<class Y>
    shared_ptr(shared_ptr<Y> const & r, boost::detail::polymorphic_cast_tag): px(dynamic_cast<element_type *>(r.px)), pn(r.pn)
    {
        if(px == 0)
        {
            boost::throw_exception(std::bad_cast());
        }
    }

#ifndef BOOST_NO_AUTO_PTR

    template<class Y>
    explicit shared_ptr(std::auto_ptr<Y> & r): px(r.get()), pn()
    {
        Y * tmp = r.get();
        pn = boost::detail::shared_count(r);
        boost::detail::sp_enable_shared_from_this( this, tmp, tmp );
    }

#if !defined( BOOST_NO_SFINAE ) && !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )

    template<class Ap>
    explicit shared_ptr( Ap r, typename boost::detail::sp_enable_if_auto_ptr<Ap, int>::type = 0 ): px( r.get() ), pn()
    {
        typename Ap::element_type * tmp = r.get();
        pn = boost::detail::shared_count( r );
        boost::detail::sp_enable_shared_from_this( this, tmp, tmp );
    }


#endif // BOOST_NO_SFINAE, BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION

#endif // BOOST_NO_AUTO_PTR

    // assignment

    shared_ptr & operator=( shared_ptr const & r ) // never throws
    {
        this_type(r).swap(*this);
        return *this;
    }

#if !defined(BOOST_MSVC) || (BOOST_MSVC >= 1400)

    template<class Y>
    shared_ptr & operator=(shared_ptr<Y> const & r) // never throws
    {
        this_type(r).swap(*this);
        return *this;
    }

#endif

#ifndef BOOST_NO_AUTO_PTR

    template<class Y>
    shared_ptr & operator=( std::auto_ptr<Y> & r )
    {
        this_type(r).swap(*this);
        return *this;
    }
#if !defined( BOOST_NO_SFINAE ) && !defined( BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION )

    template<class Ap>
    typename boost::detail::sp_enable_if_auto_ptr< Ap, shared_ptr & >::type operator=( Ap r )
    {
        this_type( r ).swap( *this );
        return *this;
    }


#endif // BOOST_NO_SFINAE, BOOST_NO_TEMPLATE_PARTIAL_SPECIALIZATION

#endif // BOOST_NO_AUTO_PTR

// Move support

#if defined( BOOST_HAS_RVALUE_REFS )

    shared_ptr( shared_ptr && r ): px( r.px ), pn() // never throws
    {
        pn.swap( r.pn );
        r.px = 0;
    }

    template<class Y>
#if !defined( BOOST_SP_NO_SP_CONVERTIBLE )

    shared_ptr( shared_ptr<Y> && r, typename boost::detail::sp_enable_if_convertible<Y,T>::type = boost::detail::sp_empty() )

#else

    shared_ptr( shared_ptr<Y> && r )

#endif
    : px( r.px ), pn() // never throws
    {
        pn.swap( r.pn );
        r.px = 0;
    }

    shared_ptr & operator=( shared_ptr && r ) // never throws
    {
        this_type( static_cast< shared_ptr && >( r ) ).swap( *this );
        return *this;
    }

    template<class Y>
    shared_ptr & operator=( shared_ptr<Y> && r ) // never throws
    {
        this_type( static_cast< shared_ptr<Y> && >( r ) ).swap( *this );
        return *this;
    }

#endif

    void reset() // never throws in 1.30+
    {
        this_type().swap(*this);
    }

    template<class Y> void reset(Y * p) // Y must be complete
    {
        BOOST_ASSERT(p == 0 || p != px); // catch self-reset errors
        this_type(p).swap(*this);
    }

    template<class Y, class D> void reset( Y * p, D d )
    {
        this_type( p, d ).swap( *this );
    }

    template<class Y, class D, class A> void reset( Y * p, D d, A a )
    {
        this_type( p, d, a ).swap( *this );
    }

    template<class Y> void reset( shared_ptr<Y> const & r, T * p )
    {
        this_type( r, p ).swap( *this );
    }

    reference operator* () const // never throws
    {
        BOOST_ASSERT(px != 0);
        return *px;
    }

    T * operator-> () const // never throws
    {
        BOOST_ASSERT(px != 0);
        return px;
    }

    T * get() const // never throws
    {
        return px;
    }

// implicit conversion to "bool"
#include <boost/smart_ptr/detail/operator_bool.hpp>

    bool unique() const // never throws
    {
        return pn.unique();
    }

    long use_count() const // never throws
    {
        return pn.use_count();
    }

    void swap(shared_ptr<T> & other) // never throws
    {
        std::swap(px, other.px);
        pn.swap(other.pn);
    }

    template<class Y> bool owner_before( shared_ptr<Y> const & rhs ) const
    {
        return pn < rhs.pn;
    }

    template<class Y> bool owner_before( weak_ptr<Y> const & rhs ) const
    {
        return pn < rhs.pn;
    }

    void * _internal_get_deleter( boost::detail::sp_typeinfo const & ti ) const
    {
        return pn.get_deleter( ti );
    }

    bool _internal_equiv( shared_ptr const & r ) const
    {
        return px == r.px && pn == r.pn;
    }

// Tasteless as this may seem, making all members public allows member templates
// to work in the absence of member template friends. (Matthew Langston)

#ifndef BOOST_NO_MEMBER_TEMPLATE_FRIENDS

private:

    template<class Y> friend class shared_ptr;
    template<class Y> friend class weak_ptr;


#endif

    T * px;                     // contained pointer
    boost::detail::shared_count pn;    // reference counter

};  // shared_ptr
template<class T, class U> inline bool operator==(shared_ptr<T> const & a, shared_ptr<U> const & b)
{
    return a.get() == b.get();
}

template<class T, class U> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<U> const & b)
{
    return a.get() != b.get();
}

#if __GNUC__ == 2 && __GNUC_MINOR__ <= 96

// Resolve the ambiguity between our op!= and the one in rel_ops

template<class T> inline bool operator!=(shared_ptr<T> const & a, shared_ptr<T> const & b)
{
    return a.get() != b.get();
}

#endif

template<class T, class U> inline bool operator<(shared_ptr<T> const & a, shared_ptr<U> const & b)
{
    return a.owner_before( b );
}

template<class T> inline void swap(shared_ptr<T> & a, shared_ptr<T> & b)
{
    a.swap(b);
}

template<class T, class U> shared_ptr<T> static_pointer_cast(shared_ptr<U> const & r)
{
    return shared_ptr<T>(r, boost::detail::static_cast_tag());
}

template<class T, class U> shared_ptr<T> const_pointer_cast(shared_ptr<U> const & r)
{
    return shared_ptr<T>(r, boost::detail::const_cast_tag());
}

template<class T, class U> shared_ptr<T> dynamic_pointer_cast(shared_ptr<U> const & r)
{
    return shared_ptr<T>(r, boost::detail::dynamic_cast_tag());
}

// shared_*_cast names are deprecated. Use *_pointer_cast instead.

template<class T, class U> shared_ptr<T> shared_static_cast(shared_ptr<U> const & r)
{
    return shared_ptr<T>(r, boost::detail::static_cast_tag());
}

template<class T, class U> shared_ptr<T> shared_dynamic_cast(shared_ptr<U> const & r)
{
    return shared_ptr<T>(r, boost::detail::dynamic_cast_tag());
}
template<class T, class U> shared_ptr<T> shared_polymorphic_cast(shared_ptr<U> const & r)
{
    return shared_ptr<T>(r, boost::detail::polymorphic_cast_tag());
}

template<class T, class U> shared_ptr<T> shared_polymorphic_downcast(shared_ptr<U> const & r)
{
    BOOST_ASSERT(dynamic_cast<T *>(r.get()) == r.get());
    return shared_static_cast<T>(r);
}

// get_pointer() enables boost::mem_fn to recognize shared_ptr

template<class T> inline T * get_pointer(shared_ptr<T> const & p)
{
    return p.get();
}

// operator<<

#if !defined(BOOST_NO_IOSTREAM)

#if defined(BOOST_NO_TEMPLATED_IOSTREAMS) || ( defined(__GNUC__) &&  (__GNUC__ < 3) )

template<class Y> std::ostream & operator<< (std::ostream & os, shared_ptr<Y> const & p)
{
    os << p.get();
    return os;
}

#else

// in STLport's no-iostreams mode no iostream symbols can be used
#ifndef _STLP_NO_IOSTREAMS

# if defined(BOOST_MSVC) && BOOST_WORKAROUND(BOOST_MSVC, < 1300 && __SGI_STL_PORT)
// MSVC6 has problems finding std::basic_ostream through the using declaration in namespace _STL
using std::basic_ostream;
template<class E, class T, class Y> basic_ostream<E, T> & operator<< (basic_ostream<E, T> & os, shared_ptr<Y> const & p)
# else
template<class E, class T, class Y> std::basic_ostream<E, T> & operator<< (std::basic_ostream<E, T> & os, shared_ptr<Y> const & p)
# endif
{
    os << p.get();
    return os;
}

#endif // _STLP_NO_IOSTREAMS

#endif // __GNUC__ < 3

#endif // !defined(BOOST_NO_IOSTREAM)

// get_deleter

#if ( defined(__GNUC__) && BOOST_WORKAROUND(__GNUC__, < 3) ) || \
    ( defined(__EDG_VERSION__) && BOOST_WORKAROUND(__EDG_VERSION__, <= 238) ) || \
    ( defined(__HP_aCC) && BOOST_WORKAROUND(__HP_aCC, <= 33500) )


// g++ 2.9x doesn't allow static_cast<X const *>(void *)
// apparently EDG 2.38 and HP aCC A.03.35 also don't accept it

template<class D, class T> D * get_deleter(shared_ptr<T> const & p)
{
    void const * q = p._internal_get_deleter(BOOST_SP_TYPEID(D));
    return const_cast<D *>(static_cast<D const *>(q));
}

#else

template<class D, class T> D * get_deleter(shared_ptr<T> const & p)
{
    return static_cast<D *>(p._internal_get_deleter(BOOST_SP_TYPEID(D)));
}

#endif

// atomic access

#if !defined(BOOST_SP_NO_ATOMIC_ACCESS)

template<class T> inline bool atomic_is_lock_free( shared_ptr<T> const * /*p*/ )
{
    return false;
}

template<class T> shared_ptr<T> atomic_load( shared_ptr<T> const * p )
{
    boost::detail::spinlock_pool<2>::scoped_lock lock( p );
    return *p;
}

template<class T> inline shared_ptr<T> atomic_load_explicit( shared_ptr<T> const * p, memory_order /*mo*/ )
{
    return atomic_load( p );
}

template<class T> void atomic_store( shared_ptr<T> * p, shared_ptr<T> r )
{
    boost::detail::spinlock_pool<2>::scoped_lock lock( p );
    p->swap( r );
}

template<class T> inline void atomic_store_explicit( shared_ptr<T> * p, shared_ptr<T> r, memory_order /*mo*/ )
{
    atomic_store( p, r ); // std::move( r )
}

template<class T> shared_ptr<T> atomic_exchange( shared_ptr<T> * p, shared_ptr<T> r )
{
    boost::detail::spinlock & sp = boost::detail::spinlock_pool<2>::spinlock_for( p );

    sp.lock();
    p->swap( r );
    sp.unlock();

    return r; // return std::move( r )
}

template<class T> shared_ptr<T> atomic_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> r, memory_order /*mo*/ )
{
    return atomic_exchange( p, r ); // std::move( r )
}

template<class T> bool atomic_compare_exchange( shared_ptr<T> * p, shared_ptr<T> * v, shared_ptr<T> w )
{
    boost::detail::spinlock & sp = boost::detail::spinlock_pool<2>::spinlock_for( p );

    sp.lock();

    if( p->_internal_equiv( *v ) )
    {
        p->swap( w );

        sp.unlock();

        return true;
    }
    else
    {
        shared_ptr<T> tmp( *p );

        sp.unlock();

        tmp.swap( *v );
        return false;
    }
}

template<class T> inline bool atomic_compare_exchange_explicit( shared_ptr<T> * p, shared_ptr<T> * v, shared_ptr<T> w, memory_order /*success*/, memory_order /*failure*/ )
{
    return atomic_compare_exchange( p, v, w ); // std::move( w )
}

#endif // !defined(BOOST_SP_NO_ATOMIC_ACCESS)

// hash_value

template< class T > struct hash;

template< class T > std::size_t hash_value( boost::shared_ptr<T> const & p )
{
    return boost::hash< T* >()( p.get() );
}

} // namespace boost

#endif  // #if defined(BOOST_NO_MEMBER_TEMPLATES) && !defined(BOOST_MSVC6_MEMBER_TEMPLATES)

#endif  // #ifndef BOOST_SMART_PTR_SHARED_PTR_HPP_INCLUDED
« 上次編輯: 2012-09-05 23:50 由 FIEND »
你累了嗎? 這樣不行 , 人要比 LINUX 兇 @@ " ......