C++深度探索系列:智能指针(Smart Pointer) [一]

C++深度探索系列:智能指针(Smart Pointer) [一]

转自 http://blog.csdn.net/RedStar81/archive/2003/03/21/19754.aspx

主题索引:

一、剖析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<<m_Idata<<endl; }
      
//             ..
      
//             }
      
//
       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
<x> m_SMPTRx(new x(m_PARAMin));
      m_SMPTRx
->DoSomething();
      }


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

      然后,还有人告诉你,可以这样用呢:
      ok1.
      auto_ptr
< x >  m_SMPTR1( new  x(m_PARAMin)); 
      auto_ptr
< x >  m_SMPTR2(m_SMPTR1);   // #2
      May be you can code # 2  like  this  :
          auto_ptr
< x >  m_SMPTR2;
          m_SMPTR2 
=  m_SMPTR1;      
      ok2.
      auto_ptr
< int >  m_SMPTR1( new   int ( 32 ));
      
      ok3.
      auto_ptr
< int >  m_SMPTR1;
      m_SMPTR1 
=  auto_ptr < int > ( new   int ( 100 ));
      也可以:
      auto_ptr
< int >  m_SMPTR1(auto_ptr < int > ( new   int ( 100 )));
      
      ok4.
      auto_ptr
< x >  m_SMPTR1( new  x(m_PARAMin));
      m_SMPTR1.reset(
new  x(m_PARAMin1));
      
      ok5.
      auto_ptr
< x >  m_SMPTR1( new  x(m_PARAMin));
      auto_ptr
< x >  m_SMPTR2(m_SMPTR.release());
      cout
<< ( * m_SMPTR2).m_Idata << endl;  
      
      ok6.
      auto_ptr
< int >  fook() {
      
return auto<int>(new int(100));
      }

 
      ok7.and so on
      
      但不可这样用:
      
      no1.   
      
char *  chrarray  =   new   char [ 100 ];
      strcpy(chrarray,
" I am programming. " );
      auto_ptr
< char *>  m_SMPTRchrptr(chrarray);
      
// auto_ptr并不可帮你管理数组资源     
       
      no2.
      vector
< auto_ptr < x >>  m_VECsmptr;
      m_VECsmptr.push_back(auto_ptr
< int > ( new   int ( 100 )));
      
// auto_ptr并不适合STL内容.
       
      no3.
      
const  auto_ptr < x >  m_SMPTR1( new  x( 100 ));
      auto_ptr
< x >  m_SMPTR( new  x( 200 ));
      
      no4.
      x m_OBJx(
300 );
      auto_ptr
< x >  m_SMPTR( & m_OBJx);
      
      no5
      x
*  m_PTR  =   new  x( 100 );
      auto_ptr
< x >  m_SMPTR  =  m_pTR;
      
      no6.and so on

      预先提及所有权的问题,以便下面带着疑问剖析代码
?

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

      power2.
      auto_ptr
< x >  m_SMPTR( new  x( 100 ));
      
      auto_ptr
< x >  returnfun(auto_ptr < x >  m_SMPTRin) {
      
return m_SMPTRin;
      }

      
      auto_ptr
< x >   =  returnfun(m_SMPTR);   // #5

      
// 在上面的#5中,我要告诉你对象所有权转移了两次.
      
// 什么叫对象所有权呢?
   
    
2 . std::auto_ptr的设计原理
       
      上面的一片正确用法,它们在干些什么
?
            一片非法,它们犯了什么罪
?
            一片什么所有权转移,它的内部机智是什么
?
      哦
! 一头雾水 ? 下面我们就来剖析其实现机制.
      基础知识:
              a.智能指针的关键技术:在于构造栈上对象的生命期控制
                堆上构造的对象的生命期.因为在智能指针的内部,存储
                着堆对象的指针,而且在构析函数中调用delete行为.
                大致机构如下:
                x
*  m_PTRx  =   new  x( 100 ); // #1
                template < typename T >
                auto_ptr
{
                
private:
                T
* m_PTR;//维护指向堆对象的指针,在auto_ptr定位后     
                .     //它应该指向#1构造的对象,即拥有所有权.
                ~auto(){ delete m_PTR; }
                .
                }

             b.所有权转移之说
               上面曾有一非法的程式片段如下:
               auto_ptr
< x >  m_SMPTR1( new  x( 100 ));
               auto_ptr
< x >  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设计为样本(去掉了无关分析的宏),来剖析其原理.
       #
1   template  < class  _Tp >   class  auto_ptr  {
       #
2  private:
       #
3  _Tp* _M_ptr;  //定义将维护堆对象的指针

       #
4  public:
       #
5  typedef _Tp element_type;  //相关类型定义
       #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 <class _Tp1> auto_ptr(auto_ptr<_Tp1>& __a) __STL_NOTHROW
                                                 : _M_ptr(__a.release()) 
{}
           
//#6、#7、#8是auto_ptr构造函数的三个版本.
           
//#6注释:传入对象的指针,构造auto_ptr.explicit关键字:禁止隐式转换.
           
//        这就是ok2正确,而no5(隐式转换)错误的原因.
           
//#7注释:拷贝构造函数.
           
//        传入auto_ptr实例,构造auto_ptr. ok1、ok3使用了这个构造式.
           
//        它是一个很关键的构造函数,在具体情况下,我们再分析
           
//#8注释:auto_ptr的模板成员,可在继承对象重载的基础上,实现特殊功能.
           
//   
           
//   举例:
           
//   class A{ public: 
           
//          virtual void fook(){cout<<"I am programming"<<endl;
           
//          /*.*/                                   }; 
           
//   class B : public A {
           
//          virtual void fook(){ cout<<"I am working"<<endl;
           
//         /*..*/                                  };  
           
//   auto_ptr<A> m_SMPTRa(new A(33));//实质:
           
//   auto_ptr<B> m_SMPTRb(m_SMPTRa); //基类的指针可以赋给派生类的指针          
           
//              
           
//   auto_ptr<B> m_SMPTRb(new B(44));//实质:
           
//   auto_ptr<A> m_SMPTRa(m_SMPTRb); //派生类的指针不可赋给基类的指针
           
//       
           
//   auto_ptr<A> m_SMPTRa(new B(33));  // ok!  
           
//   m_SMPTRa->fook()将调用派生类B的fook()
           
//   m_SMPTRa->A::fook()将调用基类A的fook()
           
//    
           
//   auto_ptr<B> 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 <class _Tp1>
       #
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 两个版本的指派函数.
          
//         delete _M_ptr; 在指派前,销毁原维护的对象.
          
//         _a.release() ; release操作,详细代码参见#20~~#23.
          
//                        用于*this获得被指派对象,
          
//                        且将原维护auto_ptr置空.
          
//     no3使用了第一种指派.
          
//     而权限转移正是_a.release()的结果.
          
       #
17 ~auto_ptr() __STL_NOTHROW { delete _M_ptr; }
          
//构析函数.消除对象.注意这里对对象的要求!
          
       #
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; }
         
//
         
//  操作符重载.
         
// #17注释:提领操作(dereference),获得对象. 见ok5用法.
         
// #18注释:成员运算符重载,返回对象指针.
         
// #19注释:普通成员函数.作用同于重载->运算符
         
//
       #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维护的对象
         
//       且迫使auto_ptr消除原来维护的对象
         
//       见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.
         
         
//下面这片段用于类型转化,目前没有任何编译器支持
         
//具体技术细节不诉.          

         #ifdef __SGI_STL_USE_AUTO_PTR_CONVERSIONS

      #
27 private:
      #
28 template<class _Tp1> 
      #
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 <class _Tp1> 
      #
33 operator auto_ptr_ref<_Tp1>() __STL_NOTHROW 
      #
34 return auto_ptr_ref<_Tp>(this->release()); }
      #
35 template <class _Tp1> operator auto_ptr<_Tp1>() __STL_NOTHROW
      #
36 return auto_ptr<_Tp1>(this->release()); }
      #
37 #endif /* __SGI_STL_USE_AUTO_PTR_CONVERSIONS */
      #
38 }
;
      
      OK
! 就是这样了.
      正如上面原理介绍处叙说,
      你需要正视两大特性:
      
1 .构造栈对象的生命期控制堆上构造的对象的生命期
      
2 .通过release来保证auto_ptr对对象的独权.
      
     在我们对源码分析的基础上,重点看看:
     no系列错误在何处
?
     no1.
         我们看到构析函数template
< class  _Tp >
                         
~ auto_ptr() _STL_NOTHROW
                        
{ delete _M_ptr; }
         所以它不能维护数组,
         维护数组需要操作:delete[] _M_ptr;
     no2.
        先提部分vector和auto_ptr代码:
        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 
< class  _T1,  class  _T2 >
         inline 
void  construct(_T1 *  __p,

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

         }
         
         Part3.
         template 
< class  _Tp,  class  _Alloc >
         
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的操作行为.
       兵分两路,可是再向下看,你会发现,无一例外,都
       通过const _Tp
&  进行拷贝行为,那么从auto_ptr提出的片段就
       派上用场了. 
       可你知道的,auto_ptr总是坚持对对象的独权.那必须修改
       原来维护的对象,而vector行为要求const _Tp
& ,这样自然会产生
       问题.一般编译器是可以发觉这种错误的.

       其实,STL所有的容器类都采用const _Tp
& 策略.
  
       
// +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
       +  看了sutter和Josuttis的两篇文章中,都提及:                     +
      
+  STL容器不支持auto_ptr原因在于copy的对象只是获得所有权的对象,  +
      
+  这种对象不符合STL的要求.可是本人总感觉即时不是真正的复制对象, +
      
+  但我用vector < auto_ptr < x >   > 的目的就在于维护对象,并不在乎       +
      
+  所谓的完全对象.而且我用自己写的Smart Pointer配合STL容器工作,  +
      
+  很正常.那需要注意的仅仅是const问题.                           +
      
+                                                                +
      
// ++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++

     no3.
        这个也是auto_ptr隐含的所有权问题引起的.
        
const  auto_ptr不允许修改.
        随便提及:const对象不代表对象一点不可以改变.
                  在两种const语义下,都有方法修改对象或对象内部指针维护的对象
                 或其它资源.
     no4.
        再看auto_ptr的构析函数.
        delete不可以消除栈上资源.

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

    
    
3 .auto_ptr高级使用指南
      
      a.类成员auto_ptr,禁止构造函数以构建
" 完全对象 "
        Programme1:
        
struct  Structx {
               
int m_Idata;
               
char m_CHRdata;
               
/**//* and so on */
        }
;
        出于对象编程的理念,
        我们将Structx打造成包裹类:
        
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
<Structx> 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;
        }
;

        处于对构建于堆中的对象(
new  Structx)智能维护的需要.
        我们将programme1改造为programme2:
        不错,对象是可以智能维护了.
        对于包裹类(StructWrapper)你是否会有这样的构造或指派操作:
         StructWrapper m_SMPTRWrapper2(m_SMPTRWrapper1);
       
         StructWrapper mSMPTRWrapper2 
=  m_SMPTRWrapper1; 
         那么请注意:
         当你坦然的来一个:M_SMPTRWrapper1
-> Soperator1();的时候,
         系统崩溃了.
         不必惊讶,所有权还是所有权问题.
         问一下自己:当programme2默认拷贝构造函数作用时,又调用了auto_ptr的
         默认构造函数,那么auto_ptr所有的默认行为都遵循独权策略.对,就这样.
         m_SMPTRWrapper1的对象所有权转移给了m_SMPTRWrapper2.
         M_SMPTRWrapper1
-> Soperator1();那么操作变成了在NULL上的.
         哦
! 系统不崩溃才怪.
         那么你需要想,programme3那样利用auto_ptr的提领操作符自己的
         构造
" 完全对象 " .

       b.利用const关键字,防止不经意的权限转移
         
         从上面的叙述,你可看出,所有权转移到处可以酿成大祸.
         而对于一般应用来说,独权又是很好的安全性策略.
         那么我们就用const来修饰auto_ptr,禁止不经意的错误.
        
         当然上面提及:并不代表auto_ptr是不可修改的.
         处于需要,从两种const语义,你都可实现修改.

         然,你还希望在函数传入传出auto_ptr那么你可传递auto_ptr的引用,
         那就万无一失了: 
void  fook( const  auto_ptr < x >&  m_PARAMin);
         在返回后赋予其它时,使用引用是不行的.你得用指针.
         因为引用无论作为lvalue还是rvaluev,都会调用构造或指派函数.


    
4 .你是否觉得std::auto_ptr还不够完美
      
      在实践中,std::auto_ptr能满足你的需求吗
?            
 
      Andrei Alexandrescu在一篇文章中,提及:有关Smart Pointer的技术就像
      巫术.Smart Pointer作为C
++ 垃圾回收机制的核心,它必须足够强大的、具有工业强度和安全性.
      但为了可一劳永逸我们还需要披荆斩棘继续探索.

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

---------------------------------------------------------------
                       [下续] 

二、C
++ 条件,寻找构造更强大的智能指针(Smart Pointer)的
    策略
    
    
1 .支持引用记数的多种设计策略
    
2 .支持处理多种资源
    
3 .支持Subclassing
    
4 .支持多线程条件下,线程安全的多种设计策略
    
5 .其它多种特殊要求下,再构造

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


四、COM实现中,Smart Pointer设计原理


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

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

--------------------------------------------------------------
                          郑重声明:
                 允许复制、修改、传递或其它行为
                 但不准用于任何商业用途.
                      写于  
20 / 3 / 2003
                      最后修改: 
20 / 3 / 2003
                         By RedStar81
                      81_RedStar@
163 .com

你可能感兴趣的:(C++深度探索系列:智能指针(Smart Pointer) [一])