auto_ptrのauto_ptr_ref

8947 ワード
職場 コンストラクタ カジュアル auto_ptr auto_ptr_ref
まずクラスauto_を見てみましょうptrの内部実現メカニズム:

  
  
  
  
    
   
   
   
   
  1.  template<typename _Tp>  
    2. 
   
   
   
   
  2.     class auto_ptr  
    3. 
   
   
   
   
  3.     {  
    4. 
   
   
   
   
  4.     private:  
    5. 
   
   
   
   
  5.       _Tp* _M_ptr;   
    6. 
   
   
   
   
  6.     public:  
    7. 
   
   
   
   
  7.       typedef _Tp element_type;  
    8. 
   
   
   
   
  8. //////**** ******/  
    9. 
   
   
   
   
  9. explicit 
    10. 
   
   
   
   
  10.       auto_ptr(element_type* __p = 0) throw() : _M_ptr(__p) { }  
    11. 
   
   
   
   
  11.  
    12. 
   
   
   
   
  12.       auto_ptr(auto_ptr& __a) throw() : _M_ptr(__a.release()) { }  
    13. 
   
   
   
   
  13.  
    14. 
   
   
   
   
  14.       template<typename _Tp1>  
    15. 
   
   
   
   
  15.         auto_ptr(auto_ptr<_Tp1>& __a) throw() : _M_ptr(__a.release()) { }  
    16. 
   
   
   
   
  16. /******* ***********/ 
    17. 
   
   
   
   
  17. auto_ptr&  
    18. 
   
   
   
   
  18.       operator=(auto_ptr& __a) throw()  
    19. 
   
   
   
   
  19.       {  
    20. 
   
   
   
   
  20.     reset(__a.release());  
    21. 
   
   
   
   
  21.     return *this;  
    22. 
   
   
   
   
  22.       }  
    23. 
   
   
   
   
  23.  
    24. 
   
   
   
   
  24.       template<typename _Tp1>  
    25. 
   
   
   
   
  25.         auto_ptr&  
    26. 
   
   
   
   
  26.         operator=(auto_ptr<_Tp1>& __a) throw()  
    27. 
   
   
   
   
  27.         {  
    28. 
   
   
   
   
  28.       reset(__a.release());  
    29. 
   
   
   
   
  29.       return *this;  
    30. 
   
   
   
   
  30.     }  
    31. 
   
   
   
   
  31. //******** ****/  
    32. 
   
   
   
   
  32.       ~auto_ptr() { delete _M_ptr; }  
    33. 
   
   
   
   
  33. /******* ****************/ 
    34. 
   
   
   
   
  34. element_type*  
    35. 
   
   
   
   
  35.       get() const throw() { return _M_ptr; }  
    36. 
   
   
   
   
  36. element_type*  
    37. 
   
   
   
   
  37.       release() throw()  
    38. 
   
   
   
   
  38.       {  
    39. 
   
   
   
   
  39.     element_type* __tmp = _M_ptr;  
    40. 
   
   
   
   
  40.     _M_ptr = 0;  
    41. 
   
   
   
   
  41.     return __tmp;  
    42. 
   
   
   
   
  42.       }  
    43. 
   
   
   
   
  43. void  reset(element_type* __p = 0) throw()  
    44. 
   
   
   
   
  44.       {  
    45. 
   
   
   
   
  45.     if (__p != _M_ptr)  
    46. 
   
   
   
   
  46.       {  
    47. 
   
   
   
   
  47.         delete _M_ptr;  
    48. 
   
   
   
   
  48.         _M_ptr = __p;  
    49. 
   
   
   
   
  49.       }  
    50. 
   
   
   
   
  50.       }  
    51. 
   
   
   
   
  51. /********* auto_ptr *********/ 
    52. 
   
   
   
   
  52. template<typename _Tp1>  
    53. 
   
   
   
   
  53.     struct auto_ptr_ref  
    54. 
   
   
   
   
  54.     {  
    55. 
   
   
   
   
  55.       _Tp1* _M_ptr;  
    56. 
   
   
   
   
  56.         
    57. 
   
   
   
   
  57.       explicit 
    58. 
   
   
   
   
  58.       auto_ptr_ref(_Tp1* __p): _M_ptr(__p) { }  
    59. 
   
   
   
   
  59.     };  
    60. 
   
   
   
   
  60. auto_ptr(auto_ptr_ref<element_type> __ref) throw()  
    61. 
   
   
   
   
  61.       : _M_ptr(__ref._M_ptr) { }  
    62. 
   
   
   
   
  62.         
    63. 
   
   
   
   
  63.       auto_ptr&  
    64. 
   
   
   
   
  64.       operator=(auto_ptr_ref<element_type> __ref) throw()  
    65. 
   
   
   
   
  65.       {  
    66. 
   
   
   
   
  66.     if (__ref._M_ptr != this->get())  
    67. 
   
   
   
   
  67.       {  
    68. 
   
   
   
   
  68.         delete _M_ptr;  
    69. 
   
   
   
   
  69.         _M_ptr = __ref._M_ptr;  
    70. 
   
   
   
   
  70.       }  
    71. 
   
   
   
   
  71.     return *this;  
    72. 
   
   
   
   
  72.       }  
    73. 
   
   
   
   
  73.         
    74. 
   
   
   
   
  74.       template<typename _Tp1>  
    75. 
   
   
   
   
  75.         operator auto_ptr_ref<_Tp1>() throw()  
    76. 
   
   
   
   
  76.         { return auto_ptr_ref<_Tp1>(this->release()); }  
    77. 
   
   
   
   
  77.  
    78. 
   
   
   
   
  78.       template<typename _Tp1>  
    79. 
   
   
   
   
  79.         operator auto_ptr<_Tp1>() throw()  
    80. 
   
   
   
   
  80.         { return auto_ptr<_Tp1>(this->release()); }  
    81. 
   
   
   
   
  81.   };  
    82. 
   
   
   
   
  82. }  
    83.

auto_があるのはptr_def、主にauto_ptrの特性、auto_ptrは、指すオブジェクトの所有権を重視し、2つ以上のauto_を持つことはできません.ptrタイプのポインタは、オブジェクトを同時に指します.これにより、そのコピーコンストラクション関数のパラメータは参照タイプであり、非常に参照されます.そこで、auto_ptr  ptr2( auto_ptr( new int(1) ) );auto_のため、文はコンパイルできません.ptr(new int(1))はright-Valueであり、右の値を参照するのは違法である.コピーコンストラクション関数を実装しない理由を考える人もいるかもしれません:auto_ptr(auto_ptr __a) throw() : _M_ptr(_a.release(){}--------(1)これでauto_ptr(auto_ptr&  __a) throw() : _M_ptr(_a.release(){}----------(2)エラーの問題をリロードしますが、(1)だけ保持するとauto_ptrはリソースの所有権の特性が消えることを強調し、Bill GibbonsとGreg ColvinBill GibbonsとGreg Colvinはテンプレートとリロードの違いを利用してauto_を導入した.ptr_ref, auto_ptr(auto_ptr_ref __ref) throw()       : _M_ptr(_ref._M_ptr){}------------------------(3)は(2)との重荷重共存が可能であり、当然auto_ptr  ptr(auto_ptr(new int(1)));コンパイル(呼び出し(3)コピーコンストラクタ)によります.同様:auto_ptr ptr = auto_ptr(new int(1))がコンパイルできるのもauto_のおかげですptr_refの機能.
白駿1461、図書館-Greedy
工学-2.1使用事例モデリング