主題索引：

一、剖析C++標準庫智慧指標(std::auto_ptr)
   
    1.Do you Smart Pointer?
    2.std::auto_ptr的設計原理
    3.std::auto_ptr高階使用指南
    4.你是否覺得std::auto_ptr還不夠完美?

二、C++條件,尋找構造更強大的智慧指標(Smart Pointer)的策略
   
    1.支援引用記數的多種設計策略
    2.支援處理多種資源
    3.支援Subclassing
    4.支援多執行緒條件下,執行緒安全的多種設計策略
    5.其它多種特殊要求下,再構造

三、Generic Programming

基礎技術和Smart Pointer
    1.回首處理資源中的Traits技術
    2.回首多執行緒支援的設計

四、COM實現中,Smart Pointer設計原理

五、著名C++庫(標準和非標準)中的Smart Pointer現狀

---------------------------------------------------------------------

一、剖析C++標準庫智慧指標(std::auto_ptr)
1.Do you Smart Pointer?      Smart Pointer,中文名：智慧指標, 舶來品?
      不可否認,資源洩露(resource leak)

曾經是C++程式的一大噩夢.垃圾回收機制(Garbage Collection)一時頗受注目.然而垃圾自動回收機制並不能滿足記憶體管理的即時性和可視性,往往使高傲的程式設計者感到不自在.
      況且,C++實現沒有引入這種機制.在探索中,C++程式設計師創造了鋒利的
      "Smart Pointer".一定程度上,解決了資源洩露問題.

也許,經常的,你會寫這樣的程式碼：
      //x擬為class:
      //            class x{
      //            public:       
      //                   int m_Idata;
      //            public:
      //                   x(int m_PARAMin):m_Idata(m_PARAMin){}
      //                   void print(){ cout<      //            .....
      //            }
      //
      void fook(){
      x* m_PTRx = new A(m_PARAMin);
      m_PTRx->DoSomething();     //#2
      delete m_PTRx;
      }

是的,這裡可能沒什麼問題.可在複雜、N行、m_PTRclassobj所指物件生命周期要求較長的情況下,你能保證你不會忘記delete m_PTRclassobj嗎?生活中,
      我們往往不應該有太多的口頭保證,我們需要做些真正有用的東西.還有一個更敏感的問題：異常.假如在#2方法執行期異常發生,函式執行終止,那麼new
      出的物件就會洩露.於是,你可能會說：那麼就捕獲異常來保證安全性好了.
      你寫這樣的程式：

      void fook(){
      A* m_PTRx = new A(m_PARAMin);
      try{
          m_PTRx->DoSomething();
      }
      catch(..){
          delete m_PTRx;
          throw;
      }
      delete m_PTRx;
      }
      哦!天哪!想象一下,你的系統,是否會象專為捕獲異常而設計的.

一天,有人給你建議:"用Smart Pointer,那很安全.".你可以這樣重寫你的程式：
   
      void fook(){
      auto_ptr m_SMPTRx(new x(m_PARAMin));
      m_SMPTRx->DoSomething();
      }

      OK!你不太相信.不用delete嗎?
      是的.不用整天提心吊膽的問自己:"我全部delete了嗎?",而且比你的delete
      策略更安全.

然後,還有人告訴你,可以這樣用呢：
      ok1.
      auto_ptr m_SMPTR1(new x(m_PARAMin));
      auto_ptr m_SMPTR2(m_SMPTR1);  //#2
      May be you can code #2 like this :
          auto_ptr m_SMPTR2;
          m_SMPTR2 = m_SMPTR1;     
      ok2.
      auto_ptr m_SMPTR1(new int(32));
     
      ok3.
      auto_ptr m_SMPTR1;
      m_SMPTR1 = auto_ptr(new int(100));
      也可以：
      auto_ptr m_SMPTR1(auto_ptr(new int(100)));
     
      ok4.
      auto_ptr m_SMPTR1(new x(m_PARAMin));
      m_SMPTR1.reset(new x(m_PARAMin1));
     
      ok5.
      auto_ptr m_SMPTR1(new x(m_PARAMin));
      auto_ptr m_SMPTR2(m_SMPTR.release());
      cout<<(*m_SMPTR2).m_Idata<
     
      ok6.
      auto_ptr fook(){
      return auto(new int(100));
      }
 
      ok7.............and so on
     
      但不可這樣用：
     
      no1.  
      char* chrarray = new char[100];
      strcpy(chrarray,"I am programming.");
      auto_ptr m_SMPTRchrptr(chrarray);
      //auto_ptr並不可幫你管理陣列資源    
      
      no2.
      vector m_VECsmptr;
      m_VECsmptr.push_back(auto_ptr(new int(100)));
      //auto_ptr並不適合STL內容.
      
      no3.
      const auto_ptr m_SMPTR1(new x(100));
      auto_ptr m_SMPTR(new x(200));
     
      no4.
      x m_OBJx(300);
      auto_ptr m_SMPTR(&m_OBJx);
     
      no5
      x* m_PTR = new x(100);
      auto_ptr m_SMPTR = m_pTR;
     
      no6..........and so on

預先提及所有權的問題,以便下面帶著疑問剖析程式碼?

      power1.
      auto_ptr m_SMPTR1(new x(100));
      auto_ptr m_SMPTR2 = m_SMPTR1;
      m_SMPTR2->print();
      //輸出：100.
      m_SMPTR1->print();
      //!! 非法的.

      power2.
      auto_ptr m_SMPTR(new x(100));
     
      auto_ptr returnfun(auto_ptr m_SMPTRin){
      return m_SMPTRin;
      }
     
      auto_ptr = returnfun(m_SMPTR);  //#5

      //在上面的#5中,我要告訴你物件所有權轉移了兩次.
      //什麼叫物件所有權呢?
  
    2. std::auto_ptr的設計原理上面的一片正確用法,它們在幹些什麼?
            一片非法,它們犯了什麼罪?
            一片什麼所有權轉移,它的內部機智是什麼?
      哦!一頭霧水?下面我們就來剖析其實現機制.
      基礎知識：
              a.智慧指標的關鍵技術：在於構造棧上物件的生命期控制堆上構造的物件的生命期.因為在智慧指標的內部,儲存著堆物件的指標,而且在構析函式中呼叫delete行為.
                大致機構如下：
                x* m_PTRx = new x(100);//#1
                template
                auto_ptr{
                private:
                T* m_PTR;//維護指向堆物件的指標,在auto_ptr定位後    
                ....     //它應該指向#1構造的物件,即擁有所有權.
                ~auto(){ delete m_PTR; }
                ....
                }
             b.所有權轉移之說上面曾有一非法的程式片段如下：
               auto_ptr m_SMPTR1(new x(100));
               auto_ptr m_SMPTR2 = m_SMPTR1;
               m_SMPTR2->print();
               //輸出：100.
               m_SMPTR1->print();
               //!! 非法的.
               按常理來說,m_SMPTR->print();怎麼是非法的呢?
               那是因為本來,m_SMPTR1維護指向new x(100)的指標,
               可是m_SMPTR2 = m_SMPTR1;auto_ptr內部機制使得m_SMPTR1將物件的地址傳給m_SMPTR2,而將自己的物件指標置為0.
               那麼自然m_SMPTR->print();失敗.
               這裡程式設計者要負明顯的職責的.
               那麼auto_ptr為什麼採取這樣的策略：保證所有權的單一性.
                                               亦保證了系統安全性.
               如果多個有全權的auto_ptr維護一個物件,那麼在你消除一個
               auto_ptr時,將導致多個auto_ptr的潛在危險.
     
       下面我們以SGI-STL的auto_ptr

相關推薦