[转]C++深度探烦�p�d��Q�智能指�?Smart Pointer) [一]

kzhang — Sun, 21 Sep 2008 16:37:00 GMT

主题索引�Q?/p>

一、剖析C++标准库智能指�?std::auto_ptr)

    1.Do you Smart Pointer?
    2.std::auto_ptr的设计原�?br>    3.std::auto_ptr高��使用指南
    4.你是否觉得std::auto_ptr�q�不够完��?

二、C++条�g,��L��构造更强大的智能指�?Smart Pointer)�?br>    �{�略

    1.支持引用记数的多�U�设计策�?br>    2.支持处理多种资源
    3.支持Subclassing
    4.支持多线�E�条件下,�U�程安全的多�U�设计策�?br>    5.其它多种�Ҏ��要求�?再构�?/p>

三、Generic Programming基础技术和Smart Pointer
1.回首处理资源中的Traits技�?br> 2.回首多线�E�支持的设计

四、COM实现�?Smart Pointer设计原理

五、著名C++�?标准和非标准)中的Smart Pointer现状

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

一、剖析C++标准库智能指�?std::auto_ptr)

    1.Do you Smart Pointer?

      Smart Pointer,中文名：��指针, 舶来�?
      不可否认,资源泄露(resource leak)曄��是C++�E�序的一大噩�?垃圾回收
      机制(Garbage Collection)一旉��受注�?然而垃圾自动回收机制�ƈ不能
      满��内存��理的即时性和可视�?往往佉K��傲的�E�序设计者感��C��自在.
      况且,C++实现没有引入�q�种机制.在探索中,C++�E�序员创造了锋利�?br>      "Smart Pointer".一定程度上,解决了资源泄露问�?

      也许,�l�常�?你会写这��L��代码�Q?br>      //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;
      }

      是的,�q�里可能没什么问�?可在复杂、N行、m_PTRclassobj所指对象生命周
      期要求较长的情况�?你能保证你不会忘记delete m_PTRclassobj�?生活�?
      我们往往不应该有太多的口头保�?我们需要做些真正有用的东西.�q�有一�?br>      更敏感的问题�Q�异�?假如�?2�Ҏ��执行期异常发�?函数执行�l�止,那么new
      出的对象��׃��泄露.于是,你可能会��_��那么��捕获异常来保证安全性好�?
      你写�q�样的程式：

      void fook(){
      A* m_PTRx = new A(m_PARAMin);
      try{
          m_PTRx->DoSomething();
      }
      catch(..){
          delete m_PTRx;
          throw;
      }
      delete m_PTRx;
      }
      �?天哪!惌��一�?你的�pȝ��,是否会象专�ؓ捕获异常而设计的.

      一�?有�h�l�你��:"用Smart Pointer,那很安全.".你可以这样重写你的程序：

      void fook(){
      auto_ptr m_SMPTRx(new x(m_PARAMin));
      m_SMPTRx->DoSomething();
      }

      OK!你不太相�?不用delete�?
      是的.不用整天提心吊胆的问自己:"我全部delete了吗?",而且比你的delete
      �{�略更安�?

      然后,�q�有人告诉你,可以�q�样用呢�Q?br>      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

      但不可这��L��Q?br>
      no1.
      char* chrarray = new char[100];
      strcpy(chrarray,"I am programming.");
      auto_ptr m_SMPTRchrptr(chrarray);
      //auto_ptr�q�不可帮你管理数�l�资�?nbsp;

      no2.
      vector> m_VECsmptr;
      m_VECsmptr.push_back(auto_ptr(new int(100)));
      //auto_ptr�q�不适合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();
      //输出�Q?00.
      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的设计原�?/strong>

      上面的一片正��用�?它们在干些什�?
            一片非�?它们犯了什么罪?
            一片什么所有权转移,它的内部机智是什�?
      �?一头雾�?下面我们��来剖析其实现机�?
      基础知识�Q?br>              a.��指针的关键技术：在于构造栈上对象的生命期控�?br>                堆上构造的对象的生命期.因�ؓ在智能指针的内部,存储
                着堆对象的指针,而且在构析函��C��调用delete行�ؓ.
                大致机构如下�Q?br>                x* m_PTRx = new x(100);//#1
                template
                auto_ptr{
                private:
                T* m_PTR;//�l�护指向堆对象的指针,在auto_ptr定位�?nbsp;
                ....     //它应该指�?1构造的对象,��x��有所有权.
                ~auto(){ delete m_PTR; }
                ....
                }
             b.所有权转移之说
               上面曾有一非法的程式片�D�如下：
               auto_ptr m_SMPTR1(new x(100));
               auto_ptr m_SMPTR2 = m_SMPTR1;
               m_SMPTR2->print();
               //输出�Q?00.
               m_SMPTR1->print();
               //!! 非法�?
               按常理来�?m_SMPTR->print();怎么是非法的�?
               那是因�ؓ本来,m_SMPTR1�l�护指向new x(100)的指�?
               可是m_SMPTR2 = m_SMPTR1;auto_ptr内部机制使得m_SMPTR1��对象的地址
               传给m_SMPTR2,而将自己的对象指针置�?.
               那么自然m_SMPTR->print();��p�|.
               �q�里�E�序设计者要负明昄��职责�?
               那么auto_ptr��Z��么采取这��L��{�略�Q�保证所有权的单一�?
                                               亦保证了�pȝ��安全�?
               如果多个有全权的auto_ptr�l�护一个对�?那么在你消除一�?br>               auto_ptr�?��导致多个auto_ptr的潜在危�?

       下面我们以SGI-STL的auto_ptr设计为样�?��L��了无兛_��析的�?,来剖析其原理.
       #1 template class auto_ptr {
       #2 private:
       #3 _Tp* _M_ptr; //定义��维护堆对象的指�?/p>

       #4 public:
       #5 typedef _Tp element_type; //相关�c�d��定义
       #6 explicit auto_ptr(_Tp* __p = 0) __STL_NOTHROW : _M_ptr(__p) {}
       #7 auto_ptr(auto_ptr& __a) __STL_NOTHROW : _M_ptr(__a.release()) {}
       #8 template auto_ptr(auto_ptr<_Tp1>& __a) __STL_NOTHROW
                                                 : _M_ptr(__a.release()) {}
           //#6�?7�?8是auto_ptr构造函数的三个版本.
           //#6注释�Q�传入对象的指针,构造auto_ptr.explicit关键�?��止隐式转换.
           //        �q�就是ok2正确,而no5(隐式转换)错误的原�?
           //#7注释�Q�拷贝构造函�?
           //        传入auto_ptr实例,构造auto_ptr. ok1、ok3使用了这个构造式.
           //        它是一个很关键的构造函�?在具体情况下,我们再分�?br>           //#8注释�Q�auto_ptr的模板成�?可在�l�承对象重蝲的基��?实现�Ҏ��功能.
           //
           //   举例�Q?br>           //   class A{ public:
           //          virtual void fook(){cout<<"I am programming"<           //          /*..........*/                                   };
           //   class B : public A {
           //          virtual void fook(){ cout<<"I am working"<           //         /*...........*/                                  };
           //   auto_ptr m_SMPTRa(new A(33));//实质�Q?br>           //   auto_ptr m_SMPTRb(m_SMPTRa); //基类的指针可以赋�l�派生类的指�?nbsp;
           //
           //   auto_ptr m_SMPTRb(new B(44));//实质�Q?br>           //   auto_ptr m_SMPTRa(m_SMPTRb); //�z��cȝ��指针不可赋给基类的指�?br>           //
           //   auto_ptr m_SMPTRa(new B(33)); // ok!
           //   m_SMPTRa->fook()��调用派生类B的fook()
           //   m_SMPTRa->A::fook()��调用基�c�A的fook()
           //
           //   auto_ptr m_SMPTRb(new A(33)); // wrong!
           //
           //
       #9 auto_ptr& operator=(auto_ptr& __a) __STL_NOTHROW {
       #10 if (&__a != this) { delete _M_ptr; _M_ptr = __a.release(); }
       #11 return *this;
       #12 }

       #13 template
       #14 auto_ptr& operator=(auto_ptr<_Tp1>& __a) __STL_NOTHROW {
       #15 if (__a.get() != this->get()) { delete _M_ptr; _M_ptr = __a.release(); }
       #16 return *this;
       #16 }
          //
          // #9~~#16 两个版本的指�z�և��?
          //         delete _M_ptr; 在指�z�։�,销毁原�l�护的对�?
          //         _a.release() ; release操作,详细代码参见#20~~#23.
          //                        用于*this获得被指�z�֯��?
          //                        且将原维护auto_ptr�|�空.
          //     no3使用了第一�U�指�z?
          //     而权限�{�U�L��是_a.release()的结�?

       #17 ~auto_ptr() __STL_NOTHROW { delete _M_ptr; }
          //构析函数.消除对象.注意�q�里对对象的要求!

       #17 _Tp& operator*() const __STL_NOTHROW { return *_M_ptr; }
       #18 _Tp* operator->() const __STL_NOTHROW { return _M_ptr; }
       #19 _Tp* get() const __STL_NOTHROW { return _M_ptr; }
         //
         // 操作�W�重�?
         // #17注释�Q�提领操�?dereference),获得对象. 见ok5用法.
         // #18注释�Q�成员运��符重蝲,�q�回对象指针.
         // #19注释�Q�普通成员函�?作用同于重蝲->�q�算�W?br>         //
       #20 _Tp* release() __STL_NOTHROW {
       #21 _Tp* __tmp = _M_ptr;
       #22 _M_ptr = 0;
       #23 return __tmp;                }
         //上面已经详解

       #24 void reset(_Tp* __p = 0) __STL_NOTHROW {
       #25 delete _M_ptr;
       #26 _M_ptr = __p;                          }
         //
         //传入对象指针,改变auto_ptr�l�护的对�?br>         //       且迫使auto_ptr消除原来�l�护的对�?br>         //       见ok3用法.

         // According to the C++ standard, these conversions are required. Most
         // present-day compilers, however, do not enforce that requirement---and,
         // in fact, most present-day compilers do not support the language
         // features that these conversions rely on.

         //下面�q�片�D는�于类型�{�?目前没有��M��~�译器支�?br>         //具体技术细节不�?

         #ifdef __SGI_STL_USE_AUTO_PTR_CONVERSIONS

      #27 private:
      #28 template
      #29 struct auto_ptr_ref { _Tp1* _M_ptr; auto_ptr_ref(_Tp1* __p) : _M_ptr(__p) {}
                             };

      #30 public:
      #31 auto_ptr(auto_ptr_ref<_Tp> __ref) __STL_NOTHROW
                               : _M_ptr(__ref._M_ptr) {}
      #32 template
      #33 operator auto_ptr_ref<_Tp1>() __STL_NOTHROW
      #34 { return auto_ptr_ref<_Tp>(this->release()); }
      #35 template operator auto_ptr<_Tp1>() __STL_NOTHROW
      #36 { return auto_ptr<_Tp1>(this->release()); }
      #37 #endif /* __SGI_STL_USE_AUTO_PTR_CONVERSIONS */
      #38 };

      OK!��是�q�样�?
      正如上面原理介绍处叙�?
      你需要正视两大特性：
      1.构造栈对象的生命期控制堆上构造的对象的生命期
      2.通过release来保证auto_ptr对对象的独权.

     在我们对源码分析的基��?重点看看�Q?br>     no�p�d��错误在何�?
     no1.
         我们看到构析函数template
                         ~auto_ptr() _STL_NOTHROW
                        { delete _M_ptr; }
         所以它不能�l�护数组,
         �l�护数组需要操作：delete[] _M_ptr;
     no2.
        先提部分vector和auto_ptr代码�Q?br>        a.提auto_ptr代码

        auto_ptr(auto_ptr& __a) __STL_NOTHROW : _M_ptr(__a.release()) {}

        b.提vector代码

          Part1:
          void push_back(const _Tp& __x) {
          if (_M_finish != _M_end_of_storage) {
          construct(_M_finish, __x);
          ++_M_finish;
          }
          else
         _M_insert_aux(end(), __x);
          }

         Part2:
         template
         inline void construct(_T1* __p,

         //++++++++++++++++++++++++++++++++
         //         const _T2& __value) { +
         //++++++++++++++++++++++++++++++++
         // new (__p) _T1(__value);      +
         //++++++++++++++++++++++++++++++++

         }

         Part3.
         template
         void
         vector<_Tp, _Alloc>::_M_insert_aux
         (iterator __position,

          //++++++++++++++++++++++++++++++++
          //        const _Tp& __x)       ++
          //++++++++++++++++++++++++++++++++

         {
         if (_M_finish != _M_end_of_storage) {
         construct(_M_finish, *(_M_finish - 1));
         ++_M_finish;

         //++++++++++++++++++++++++++++++++
         //     _Tp __x_copy = __x;       +
         //++++++++++++++++++++++++++++++++

         copy_backward(__position, _M_finish - 2, _M_finish - 1);
         *__position = __x_copy;
         }
         else {
         const size_type __old_size = size();
         const size_type __len = __old_size != 0 ? 2 * __old_size : 1;
         iterator __new_start = _M_allocate(__len);
         iterator __new_finish = __new_start;
         __STL_TRY {
         __new_finish = uninitialized_copy
         (_M_start, __position, __new_start);
         construct(__new_finish, __x);
         ++__new_finish;
         __new_finish = uninitialized_copy
        (__position, _M_finish, __new_finish);
        }
        __STL_UNWIND((destroy(__new_start,__new_finish),
                  _M_deallocate(__new_start,__len)));
       destroy(begin(), end());
       _M_deallocate(_M_start, _M_end_of_storage - _M_start);
       _M_start = __new_start;
       _M_finish = __new_finish;
       _M_end_of_storage = __new_start + __len;
       }
       }

       从提取的vector代码,Part1可看�?push_back的操作行�?
       兵分两�\,可是再向下看,你会发现,无一例外,�?br>       通过const _Tp& �q�行拯��行�ؓ,那么从auto_ptr提出的片�D�就
       �z�上用场�?
       可你知道�?auto_ptr��L��坚持对对象的独权.那必��M��?br>       原来�l�护的对�?而vector行�ؓ要求const _Tp&,�q�样自然会��?br>       问题.一般编译器是可以发觉这�U�错误的.

       其实,STL所有的容器�c�都采用const _Tp&�{�略.

       //+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
      + 看了sutter和Josuttis的两��文章中,都提及：                    +
      + STL容器不支持auto_ptr原因在于copy的对象只是获得所有权的对�? +
      + �q�种对象不符合STL的要�?可是本�h��L��觉即时不是真正的复制对象,+
      + 但我用vector >的目的就在于�l�护对象,�q�不在乎      +
      + 所谓的完全对象.而且我用自己写的Smart Pointer配合STL容器工作, +
      + 很正�?那需要注意的仅仅是const问题.                          +
      +                                                              +
      //++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

     no3.
        �q�个也是auto_ptr隐含的所有权问题引�v�?
        const auto_ptr不允�怿��?
        随便提及�Q�const对象不代表对象一点不可以改变.
                  在两�U�const语义�?都有�Ҏ��修改对象或对象内部指针维护的对象
                 或其它资�?
     no4.
        再看auto_ptr的构析函�?
        delete不可以消除栈上资�?

     no5.
        依赖传入对象指针的构造函数被声明为explicit,��止隐式转换.


    3.auto_ptr高��使用指南

      a.�c�L��员auto_ptr,��止构造函��C��构徏"完全对象"
        Programme1:
        struct Structx{
               int m_Idata;
               char m_CHRdata;
               /* and so on */
        };
        ��Z��对象�~�程的理�?
        我们��Structx打造成包裹�c�：
        class StructWrapper{
        private:
        Structx* m_STRTxptr;
        public:
        StructWrapper():m_STRTxptr(new Structx){}
        ~StructWrapper(){delete m_SMRTxptr; }
        public:
        void Soperator1(){ /* 针对Structx对象的特性操�?*/}
        void Soperator2(){ /* 针对Structx对象的特性操�?*/}
        /* and so on */
        };

        Programme2:
        class StructWrapper{
        private:
        auto_ptr m_SMPTRx;
        public:
        StructWrapper():m_SMPTRAx(new Structx){}
        public:
        void Soperator1(){ /* 针对Structx对象的特性操�?*/}
        void Soperator2(){ /* 针对Structx对象的特性操�?*/}
        /* and so on */
        };

        Programme3:
        StructWrapper::StructWrapper(const StructWrapper& other)
        : M_SMPTRx(new Struct(*other.m_SMPTRx)) { }
        StructWrapper& StructWrapper::operator=(const StructWrapper &other){
        *m_SMPTRx = *other.m_SMPTRx;
        };

        处于�Ҏ��Z��堆中的对�?new Structx)��l�护的需�?
        我们��programme1攚w��ؓprogramme2�Q?br>        不错,对象是可以智能维护了.
        对于包裹�c?StructWrapper)你是否会有这��L��构造或指派操作�Q?br>         StructWrapper m_SMPTRWrapper2(m_SMPTRWrapper1);

         StructWrapper mSMPTRWrapper2 = m_SMPTRWrapper1;
         那么��h��意：
         当你坦然的来一个：M_SMPTRWrapper1->Soperator1();的时�?
         �pȝ��崩溃�?
         不必惊讶,所有权�q�是所有权问题.
         问一下自己：当programme2默认拯��构造函��C��用时,又调用了auto_ptr�?br>         默认构造函�?那么auto_ptr所有的默认行�ؓ都遵循独权策�?�?��p��?
         m_SMPTRWrapper1的对象所有权转移�l�了m_SMPTRWrapper2.
         M_SMPTRWrapper1->Soperator1();那么操作变成了在NULL上的.
         �?�pȝ��不崩溃才�?
         那么你需要想,programme3那样利用auto_ptr的提领操作符自己�?br>         构�?完全对象".

       b.利用const关键�?防止不经意的权限转移

         从上面的叙述,你可看出,所有权转移到处可以酿成大祸.
         而对于一般应用来�?独权又是很好的安全性策�?
         那么我们��q��const来修饰auto_ptr,��止不经意的错误.

         当然上面提及�Q��ƈ不代表auto_ptr是不可修改的.
         处于需�?从两�U�const语义,你都可实��C��?

         �?你还希望在函��C��入传出auto_ptr那么你可传递auto_ptr的引�?
         那就万无一�׃��: void fook(const auto_ptr& m_PARAMin);
         在返回后赋予其它�?使用引用是不行的.你得用指�?
         因�ؓ引用无论作�ؓlvalue�q�是rvaluev,都会调用构造或指派函数.

    4.你是否觉得std::auto_ptr�q�不够完��?/font>

      在实践中,std::auto_ptr能满��你的需求吗?

      Andrei Alexandrescu在一��文章中,提及�Q�有关Smart Pointer的技术就�?br>      巫术.Smart Pointer作�ؓC++垃圾回收机制的核�?它必��够强大的、具有工业强度和安全�?
      但�ؓ了可一��x��逸我们还需要披荆斩��l�探�?

      下面在需求层面上,我们思烦一下我们的��指针�q�需要些什�?

        a. std::auto_ptr 能够处理数组�?我们可以用智能指针来��理其它的资源吗?
           譬如一个线�E�句柄、一个文件句�?and so on !
        b. 对于我们的对象真的永�q�实行独权政�{�吗?
        c. Our ��指针�q�需要在�l�承和虚拟层面上发挥威力 !
        d. 往往,需要扩展Our ��指针的功能成员函数来满��动态的需�?!
        e. 也许,你需要的�q�很�?

---------------------------------------------------------------
                       [下箋]

二、C++条�g,��L��构造更强大的智能指�?Smart Pointer)�?br>    �{�略

    1.支持引用记数的多�U�设计策�?br>    2.支持处理多种资源
    3.支持Subclassing
    4.支持多线�E�条件下,�U�程安全的多�U�设计策�?br>    5.其它多种�Ҏ��要求�?再构�?/p>
三、Generic Programming基础技术和Smart Pointer
    1.回首处理资源中的Traits技�?br>    2.回首多线�E�支持的设计

四、COM实现�?Smart Pointer设计原理

五、著名C++�?标准和非标准)中的Smart Pointer现状

-----------------------------------------------------------
--------------------------------------------------------------
                          郑重声明�Q?br>                 允许复制、修攏V��传递或其它行�ؓ
                 但不准用于�Q何商业用�?
                      写于 20/3/2003
                      最后修改： 20/3/2003
                         By RedStar81
                      81_RedStar@163.com
-------------------------------------------------------------

kzhang 2008-09-22 00:37 发表评论

欧美激情精品久久久久久久九九九 ,久久无码AV中文出轨人妻,婷婷久久精品国产

[转]C++深度探烦�p�d���Q�智能指�?Smart Pointer) [一]

[转]C++深度探烦�p�d��Q�智能指�?Smart Pointer) [一]