shared_ptr.h

Go to the documentation of this file.
00001 // shared_ptr and weak_ptr implementation -*- C++ -*-
00002 
00003 // Copyright (C) 2007, 2008, 2009, 2010 Free Software Foundation, Inc.
00004 //
00005 // This file is part of the GNU ISO C++ Library.  This library is free
00006 // software; you can redistribute it and/or modify it under the
00007 // terms of the GNU General Public License as published by the
00008 // Free Software Foundation; either version 3, or (at your option)
00009 // any later version.
00010 
00011 // This library is distributed in the hope that it will be useful,
00012 // but WITHOUT ANY WARRANTY; without even the implied warranty of
00013 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
00014 // GNU General Public License for more details.
00015 
00016 // Under Section 7 of GPL version 3, you are granted additional
00017 // permissions described in the GCC Runtime Library Exception, version
00018 // 3.1, as published by the Free Software Foundation.
00019 
00020 // You should have received a copy of the GNU General Public License and
00021 // a copy of the GCC Runtime Library Exception along with this program;
00022 // see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
00023 // <http://www.gnu.org/licenses/>.
00024 
00025 // GCC Note: Based on files from version 1.32.0 of the Boost library.
00026 
00027 //  shared_count.hpp
00028 //  Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
00029 
00030 //  shared_ptr.hpp
00031 //  Copyright (C) 1998, 1999 Greg Colvin and Beman Dawes.
00032 //  Copyright (C) 2001, 2002, 2003 Peter Dimov
00033 
00034 //  weak_ptr.hpp
00035 //  Copyright (C) 2001, 2002, 2003 Peter Dimov
00036 
00037 //  enable_shared_from_this.hpp
00038 //  Copyright (C) 2002 Peter Dimov
00039 
00040 // Distributed under the Boost Software License, Version 1.0. (See
00041 // accompanying file LICENSE_1_0.txt or copy at
00042 // http://www.boost.org/LICENSE_1_0.txt)
00043 
00044 /** @file bits/shared_ptr.h
00045  *  This is an internal header file, included by other library headers.
00046  *  You should not attempt to use it directly.
00047  */
00048 
00049 #ifndef _SHARED_PTR_H
00050 #define _SHARED_PTR_H 1
00051 
00052 #include <bits/shared_ptr_base.h>
00053 
00054 _GLIBCXX_BEGIN_NAMESPACE(std)
00055 
00056   /**
00057    * @addtogroup pointer_abstractions
00058    * @{
00059    */
00060 
00061   /// 2.2.3.7 shared_ptr I/O
00062   template<typename _Ch, typename _Tr, typename _Tp, _Lock_policy _Lp>
00063     inline std::basic_ostream<_Ch, _Tr>&
00064     operator<<(std::basic_ostream<_Ch, _Tr>& __os,
00065            const __shared_ptr<_Tp, _Lp>& __p)
00066     {
00067       __os << __p.get();
00068       return __os;
00069     }
00070 
00071   /// 2.2.3.10 shared_ptr get_deleter (experimental)
00072   template<typename _Del, typename _Tp, _Lock_policy _Lp>
00073     inline _Del*
00074     get_deleter(const __shared_ptr<_Tp, _Lp>& __p)
00075     {
00076 #ifdef __GXX_RTTI
00077       return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del)));
00078 #else
00079       return 0;
00080 #endif
00081     }
00082 
00083 
00084   /**
00085    *  @brief  A smart pointer with reference-counted copy semantics.
00086    *
00087    *  The object pointed to is deleted when the last shared_ptr pointing to
00088    *  it is destroyed or reset.
00089   */
00090   template<typename _Tp>
00091     class shared_ptr : public __shared_ptr<_Tp>
00092     {
00093     public:
00094       /**
00095        *  @brief  Construct an empty %shared_ptr.
00096        *  @post   use_count()==0 && get()==0
00097        */
00098       shared_ptr() : __shared_ptr<_Tp>() { }
00099 
00100       /**
00101        *  @brief  Construct a %shared_ptr that owns the pointer @a __p.
00102        *  @param  __p  A pointer that is convertible to element_type*.
00103        *  @post   use_count() == 1 && get() == __p
00104        *  @throw  std::bad_alloc, in which case @c delete @a __p is called.
00105        */
00106       template<typename _Tp1>
00107     explicit shared_ptr(_Tp1* __p) : __shared_ptr<_Tp>(__p) { }
00108 
00109       /**
00110        *  @brief  Construct a %shared_ptr that owns the pointer @a __p
00111        *          and the deleter @a __d.
00112        *  @param  __p  A pointer.
00113        *  @param  __d  A deleter.
00114        *  @post   use_count() == 1 && get() == __p
00115        *  @throw  std::bad_alloc, in which case @a __d(__p) is called.
00116        *
00117        *  Requirements: _Deleter's copy constructor and destructor must
00118        *  not throw
00119        *
00120        *  __shared_ptr will release __p by calling __d(__p)
00121        */
00122       template<typename _Tp1, typename _Deleter>
00123     shared_ptr(_Tp1* __p, _Deleter __d) : __shared_ptr<_Tp>(__p, __d) { }
00124 
00125       /**
00126        *  @brief  Construct a %shared_ptr that owns a null pointer
00127        *          and the deleter @a __d.
00128        *  @param  __p  A null pointer constant.
00129        *  @param  __d  A deleter.
00130        *  @post   use_count() == 1 && get() == __p
00131        *  @throw  std::bad_alloc, in which case @a __d(__p) is called.
00132        *
00133        *  Requirements: _Deleter's copy constructor and destructor must
00134        *  not throw
00135        *
00136        *  The last owner will call __d(__p)
00137        */
00138       template<typename _Deleter>
00139     shared_ptr(nullptr_t __p, _Deleter __d)
00140         : __shared_ptr<_Tp>(__p, __d) { }
00141 
00142       /**
00143        *  @brief  Construct a %shared_ptr that owns the pointer @a __p
00144        *          and the deleter @a __d.
00145        *  @param  __p  A pointer.
00146        *  @param  __d  A deleter.
00147        *  @param  __a  An allocator.
00148        *  @post   use_count() == 1 && get() == __p
00149        *  @throw  std::bad_alloc, in which case @a __d(__p) is called.
00150        *
00151        *  Requirements: _Deleter's copy constructor and destructor must
00152        *  not throw _Alloc's copy constructor and destructor must not
00153        *  throw.
00154        *
00155        *  __shared_ptr will release __p by calling __d(__p)
00156        */
00157       template<typename _Tp1, typename _Deleter, typename _Alloc>
00158     shared_ptr(_Tp1* __p, _Deleter __d, const _Alloc& __a)
00159     : __shared_ptr<_Tp>(__p, __d, __a) { }
00160 
00161       /**
00162        *  @brief  Construct a %shared_ptr that owns a null pointer
00163        *          and the deleter @a __d.
00164        *  @param  __p  A null pointer constant.
00165        *  @param  __d  A deleter.
00166        *  @param  __a  An allocator.
00167        *  @post   use_count() == 1 && get() == __p
00168        *  @throw  std::bad_alloc, in which case @a __d(__p) is called.
00169        *
00170        *  Requirements: _Deleter's copy constructor and destructor must
00171        *  not throw _Alloc's copy constructor and destructor must not
00172        *  throw.
00173        *
00174        *  The last owner will call __d(__p)
00175        */
00176       template<typename _Deleter, typename _Alloc>
00177     shared_ptr(nullptr_t __p, _Deleter __d, const _Alloc& __a)
00178     : __shared_ptr<_Tp>(__p, __d, __a) { }
00179 
00180       // Aliasing constructor
00181 
00182       /**
00183        *  @brief  Constructs a %shared_ptr instance that stores @a __p
00184        *          and shares ownership with @a __r.
00185        *  @param  __r  A %shared_ptr.
00186        *  @param  __p  A pointer that will remain valid while @a *__r is valid.
00187        *  @post   get() == __p && use_count() == __r.use_count()
00188        *
00189        *  This can be used to construct a @c shared_ptr to a sub-object
00190        *  of an object managed by an existing @c shared_ptr.
00191        *
00192        * @code
00193        * shared_ptr< pair<int,int> > pii(new pair<int,int>());
00194        * shared_ptr<int> pi(pii, &pii->first);
00195        * assert(pii.use_count() == 2);
00196        * @endcode
00197        */
00198       template<typename _Tp1>
00199     shared_ptr(const shared_ptr<_Tp1>& __r, _Tp* __p)
00200     : __shared_ptr<_Tp>(__r, __p) { }
00201 
00202       /**
00203        *  @brief  If @a __r is empty, constructs an empty %shared_ptr;
00204        *          otherwise construct a %shared_ptr that shares ownership
00205        *          with @a __r.
00206        *  @param  __r  A %shared_ptr.
00207        *  @post   get() == __r.get() && use_count() == __r.use_count()
00208        */
00209       template<typename _Tp1, typename = typename
00210            std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
00211     shared_ptr(const shared_ptr<_Tp1>& __r)
00212         : __shared_ptr<_Tp>(__r) { }
00213 
00214       /**
00215        *  @brief  Move-constructs a %shared_ptr instance from @a __r.
00216        *  @param  __r  A %shared_ptr rvalue.
00217        *  @post   *this contains the old value of @a __r, @a __r is empty.
00218        */
00219       shared_ptr(shared_ptr&& __r)
00220       : __shared_ptr<_Tp>(std::move(__r)) { }
00221 
00222       /**
00223        *  @brief  Move-constructs a %shared_ptr instance from @a __r.
00224        *  @param  __r  A %shared_ptr rvalue.
00225        *  @post   *this contains the old value of @a __r, @a __r is empty.
00226        */
00227       template<typename _Tp1, typename = typename
00228            std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
00229     shared_ptr(shared_ptr<_Tp1>&& __r)
00230     : __shared_ptr<_Tp>(std::move(__r)) { }
00231 
00232       /**
00233        *  @brief  Constructs a %shared_ptr that shares ownership with @a __r
00234        *          and stores a copy of the pointer stored in @a __r.
00235        *  @param  __r  A weak_ptr.
00236        *  @post   use_count() == __r.use_count()
00237        *  @throw  bad_weak_ptr when __r.expired(),
00238        *          in which case the constructor has no effect.
00239        */
00240       template<typename _Tp1>
00241     explicit shared_ptr(const weak_ptr<_Tp1>& __r)
00242     : __shared_ptr<_Tp>(__r) { }
00243 
00244 #if _GLIBCXX_DEPRECATED
00245       template<typename _Tp1>
00246     shared_ptr(std::auto_ptr<_Tp1>&& __r)
00247     : __shared_ptr<_Tp>(std::move(__r)) { }
00248 #endif
00249 
00250       template<typename _Tp1, typename _Del>
00251     shared_ptr(std::unique_ptr<_Tp1, _Del>&& __r)
00252     : __shared_ptr<_Tp>(std::move(__r)) { }
00253 
00254       /**
00255        *  @brief  Construct an empty %shared_ptr.
00256        *  @param  __p  A null pointer constant.
00257        *  @post   use_count() == 0 && get() == nullptr
00258        */
00259       shared_ptr(nullptr_t __p) : __shared_ptr<_Tp>(__p) { }
00260 
00261       template<typename _Tp1>
00262     shared_ptr&
00263     operator=(const shared_ptr<_Tp1>& __r) // never throws
00264     {
00265       this->__shared_ptr<_Tp>::operator=(__r);
00266       return *this;
00267     }
00268 
00269 #if _GLIBCXX_DEPRECATED
00270       template<typename _Tp1>
00271     shared_ptr&
00272     operator=(std::auto_ptr<_Tp1>&& __r)
00273     {
00274       this->__shared_ptr<_Tp>::operator=(std::move(__r));
00275       return *this;
00276     }
00277 #endif
00278 
00279       shared_ptr&
00280       operator=(shared_ptr&& __r)
00281       {
00282     this->__shared_ptr<_Tp>::operator=(std::move(__r));
00283     return *this;
00284       }
00285 
00286       template<class _Tp1>
00287     shared_ptr&
00288     operator=(shared_ptr<_Tp1>&& __r)
00289     {
00290       this->__shared_ptr<_Tp>::operator=(std::move(__r));
00291       return *this;
00292     }
00293 
00294       template<typename _Tp1, typename _Del>
00295     shared_ptr&
00296     operator=(std::unique_ptr<_Tp1, _Del>&& __r)
00297     {
00298       this->__shared_ptr<_Tp>::operator=(std::move(__r));
00299       return *this;
00300     }
00301 
00302     private:
00303       // This constructor is non-standard, it is used by allocate_shared.
00304       template<typename _Alloc, typename... _Args>
00305     shared_ptr(_Sp_make_shared_tag __tag, _Alloc __a, _Args&&... __args)
00306     : __shared_ptr<_Tp>(__tag, __a, std::forward<_Args>(__args)...)
00307     { }
00308 
00309       template<typename _Tp1, typename _Alloc, typename... _Args>
00310     friend shared_ptr<_Tp1>
00311     allocate_shared(_Alloc __a, _Args&&... __args);
00312     };
00313 
00314   // 20.8.13.2.7 shared_ptr comparisons
00315   template<typename _Tp1, typename _Tp2>
00316     inline bool
00317     operator==(const shared_ptr<_Tp1>& __a, const shared_ptr<_Tp2>& __b)
00318     { return __a.get() == __b.get(); }
00319 
00320   template<typename _Tp>
00321     inline bool
00322     operator==(const shared_ptr<_Tp>& __a, nullptr_t)
00323     { return __a.get() == nullptr; }
00324 
00325   template<typename _Tp>
00326     inline bool
00327     operator==(nullptr_t, const shared_ptr<_Tp>& __b)
00328     { return nullptr == __b.get(); }
00329 
00330   template<typename _Tp1, typename _Tp2>
00331     inline bool
00332     operator!=(const shared_ptr<_Tp1>& __a, const shared_ptr<_Tp2>& __b)
00333     { return __a.get() != __b.get(); }
00334 
00335   template<typename _Tp>
00336     inline bool
00337     operator!=(const shared_ptr<_Tp>& __a, nullptr_t)
00338     { return __a.get() != nullptr; }
00339 
00340   template<typename _Tp>
00341     inline bool
00342     operator!=(nullptr_t, const shared_ptr<_Tp>& __b)
00343     { return nullptr != __b.get(); }
00344 
00345   template<typename _Tp1, typename _Tp2>
00346     inline bool
00347     operator<(const shared_ptr<_Tp1>& __a, const shared_ptr<_Tp2>& __b)
00348     { return __a.get() < __b.get(); }
00349 
00350   template<typename _Tp>
00351     struct less<shared_ptr<_Tp>> : public _Sp_less<shared_ptr<_Tp>>
00352     { };
00353 
00354   // 20.8.13.2.9 shared_ptr specialized algorithms.
00355   template<typename _Tp>
00356     inline void
00357     swap(shared_ptr<_Tp>& __a, shared_ptr<_Tp>& __b)
00358     { __a.swap(__b); }
00359 
00360   // 20.8.13.2.10 shared_ptr casts.
00361   template<typename _Tp, typename _Tp1>
00362     inline shared_ptr<_Tp>
00363     static_pointer_cast(const shared_ptr<_Tp1>& __r)
00364     { return shared_ptr<_Tp>(__r, static_cast<_Tp*>(__r.get())); }
00365 
00366   template<typename _Tp, typename _Tp1>
00367     inline shared_ptr<_Tp>
00368     const_pointer_cast(const shared_ptr<_Tp1>& __r)
00369     { return shared_ptr<_Tp>(__r, const_cast<_Tp*>(__r.get())); }
00370 
00371   template<typename _Tp, typename _Tp1>
00372     inline shared_ptr<_Tp>
00373     dynamic_pointer_cast(const shared_ptr<_Tp1>& __r)
00374     {
00375       if (_Tp* __p = dynamic_cast<_Tp*>(__r.get()))
00376     return shared_ptr<_Tp>(__r, __p);
00377       return shared_ptr<_Tp>();
00378     }
00379 
00380 
00381   /**
00382    *  @brief  A smart pointer with weak semantics.
00383    *
00384    *  With forwarding constructors and assignment operators.
00385    */
00386   template<typename _Tp>
00387     class weak_ptr : public __weak_ptr<_Tp>
00388     {
00389     public:
00390       weak_ptr() : __weak_ptr<_Tp>() { }
00391 
00392       template<typename _Tp1, typename = typename
00393            std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
00394     weak_ptr(const weak_ptr<_Tp1>& __r)
00395     : __weak_ptr<_Tp>(__r) { }
00396 
00397       template<typename _Tp1, typename = typename
00398            std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type>
00399     weak_ptr(const shared_ptr<_Tp1>& __r)
00400     : __weak_ptr<_Tp>(__r) { }
00401 
00402       template<typename _Tp1>
00403     weak_ptr&
00404     operator=(const weak_ptr<_Tp1>& __r) // never throws
00405     {
00406       this->__weak_ptr<_Tp>::operator=(__r);
00407       return *this;
00408     }
00409 
00410       template<typename _Tp1>
00411     weak_ptr&
00412     operator=(const shared_ptr<_Tp1>& __r) // never throws
00413     {
00414       this->__weak_ptr<_Tp>::operator=(__r);
00415       return *this;
00416     }
00417 
00418       shared_ptr<_Tp>
00419       lock() const // never throws
00420       {
00421 #ifdef __GTHREADS
00422     if (this->expired())
00423       return shared_ptr<_Tp>();
00424 
00425     __try
00426       {
00427         return shared_ptr<_Tp>(*this);
00428       }
00429     __catch(const bad_weak_ptr&)
00430       {
00431         return shared_ptr<_Tp>();
00432       }
00433 #else
00434     return this->expired() ? shared_ptr<_Tp>() : shared_ptr<_Tp>(*this);
00435 #endif
00436       }
00437     };
00438 
00439   // 20.8.13.3.7 weak_ptr specialized algorithms.
00440   template<typename _Tp>
00441     inline void
00442     swap(weak_ptr<_Tp>& __a, weak_ptr<_Tp>& __b)
00443     { __a.swap(__b); }
00444 
00445 
00446   /// Primary template owner_less
00447   template<typename _Tp>
00448     struct owner_less;
00449 
00450   /// Partial specialization of owner_less for shared_ptr.
00451   template<typename _Tp>
00452     struct owner_less<shared_ptr<_Tp>>
00453     : public _Sp_owner_less<shared_ptr<_Tp>, weak_ptr<_Tp>>
00454     { };
00455 
00456   /// Partial specialization of owner_less for weak_ptr.
00457   template<typename _Tp>
00458     struct owner_less<weak_ptr<_Tp>>
00459     : public _Sp_owner_less<weak_ptr<_Tp>, shared_ptr<_Tp>>
00460     { };
00461 
00462   /**
00463    *  @brief Base class allowing use of member function shared_from_this.
00464    */
00465   template<typename _Tp>
00466     class enable_shared_from_this
00467     {
00468     protected:
00469       enable_shared_from_this() { }
00470 
00471       enable_shared_from_this(const enable_shared_from_this&) { }
00472 
00473       enable_shared_from_this&
00474       operator=(const enable_shared_from_this&)
00475       { return *this; }
00476 
00477       ~enable_shared_from_this() { }
00478 
00479     public:
00480       shared_ptr<_Tp>
00481       shared_from_this()
00482       { return shared_ptr<_Tp>(this->_M_weak_this); }
00483 
00484       shared_ptr<const _Tp>
00485       shared_from_this() const
00486       { return shared_ptr<const _Tp>(this->_M_weak_this); }
00487 
00488     private:
00489       template<typename _Tp1>
00490     void
00491     _M_weak_assign(_Tp1* __p, const __shared_count<>& __n) const
00492     { _M_weak_this._M_assign(__p, __n); }
00493 
00494       template<typename _Tp1>
00495     friend void
00496     __enable_shared_from_this_helper(const __shared_count<>& __pn,
00497                      const enable_shared_from_this* __pe,
00498                      const _Tp1* __px)
00499     {
00500       if (__pe != 0)
00501         __pe->_M_weak_assign(const_cast<_Tp1*>(__px), __pn);
00502     }
00503 
00504       mutable weak_ptr<_Tp>  _M_weak_this;
00505     };
00506 
00507   /**
00508    *  @brief  Create an object that is owned by a shared_ptr.
00509    *  @param  __a     An allocator.
00510    *  @param  __args  Arguments for the @a _Tp object's constructor.
00511    *  @return A shared_ptr that owns the newly created object.
00512    *  @throw  An exception thrown from @a _Alloc::allocate or from the
00513    *          constructor of @a _Tp.
00514    *
00515    *  A copy of @a __a will be used to allocate memory for the shared_ptr
00516    *  and the new object.
00517    */
00518   template<typename _Tp, typename _Alloc, typename... _Args>
00519     inline shared_ptr<_Tp>
00520     allocate_shared(_Alloc __a, _Args&&... __args)
00521     {
00522       return shared_ptr<_Tp>(_Sp_make_shared_tag(), std::forward<_Alloc>(__a),
00523                  std::forward<_Args>(__args)...);
00524     }
00525 
00526   /**
00527    *  @brief  Create an object that is owned by a shared_ptr.
00528    *  @param  __args  Arguments for the @a _Tp object's constructor.
00529    *  @return A shared_ptr that owns the newly created object.
00530    *  @throw  std::bad_alloc, or an exception thrown from the
00531    *          constructor of @a _Tp.
00532    */
00533   template<typename _Tp, typename... _Args>
00534     inline shared_ptr<_Tp>
00535     make_shared(_Args&&... __args)
00536     {
00537       typedef typename std::remove_const<_Tp>::type _Tp_nc;
00538       return allocate_shared<_Tp>(std::allocator<_Tp_nc>(),
00539                   std::forward<_Args>(__args)...);
00540     }
00541 
00542   /// std::hash specialization for shared_ptr.
00543   template<typename _Tp>
00544     struct hash<shared_ptr<_Tp>>
00545     : public std::unary_function<shared_ptr<_Tp>, size_t>
00546     {
00547       size_t
00548       operator()(const shared_ptr<_Tp>& __s) const
00549       { return std::hash<_Tp*>()(__s.get()); }
00550     };
00551 
00552   // @} group pointer_abstractions
00553 
00554 _GLIBCXX_END_NAMESPACE
00555 
00556 #endif // _SHARED_PTR_H