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