libstdc++
|
00001 // shared_ptr and weak_ptr implementation -*- C++ -*- 00002 00003 // Copyright (C) 2007-2014 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 /// 20.7.2.2.11 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 /// 20.7.2.2.10 shared_ptr get_deleter 00074 template<typename _Del, typename _Tp, _Lock_policy _Lp> 00075 inline _Del* 00076 get_deleter(const __shared_ptr<_Tp, _Lp>& __p) noexcept 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() noexcept 00101 : __shared_ptr<_Tp>() { } 00102 00103 shared_ptr(const shared_ptr&) noexcept = default; 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) noexcept 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) noexcept 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) noexcept 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) noexcept 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 #endif 00255 00256 template<typename _Tp1, typename _Del> 00257 shared_ptr(std::unique_ptr<_Tp1, _Del>&& __r) 00258 : __shared_ptr<_Tp>(std::move(__r)) { } 00259 00260 /** 00261 * @brief Construct an empty %shared_ptr. 00262 * @param __p A null pointer constant. 00263 * @post use_count() == 0 && get() == nullptr 00264 */ 00265 constexpr shared_ptr(nullptr_t __p) noexcept 00266 : __shared_ptr<_Tp>(__p) { } 00267 00268 shared_ptr& operator=(const shared_ptr&) noexcept = default; 00269 00270 template<typename _Tp1> 00271 shared_ptr& 00272 operator=(const shared_ptr<_Tp1>& __r) noexcept 00273 { 00274 this->__shared_ptr<_Tp>::operator=(__r); 00275 return *this; 00276 } 00277 00278 #if _GLIBCXX_USE_DEPRECATED 00279 template<typename _Tp1> 00280 shared_ptr& 00281 operator=(std::auto_ptr<_Tp1>&& __r) 00282 { 00283 this->__shared_ptr<_Tp>::operator=(std::move(__r)); 00284 return *this; 00285 } 00286 #endif 00287 00288 shared_ptr& 00289 operator=(shared_ptr&& __r) noexcept 00290 { 00291 this->__shared_ptr<_Tp>::operator=(std::move(__r)); 00292 return *this; 00293 } 00294 00295 template<class _Tp1> 00296 shared_ptr& 00297 operator=(shared_ptr<_Tp1>&& __r) noexcept 00298 { 00299 this->__shared_ptr<_Tp>::operator=(std::move(__r)); 00300 return *this; 00301 } 00302 00303 template<typename _Tp1, typename _Del> 00304 shared_ptr& 00305 operator=(std::unique_ptr<_Tp1, _Del>&& __r) 00306 { 00307 this->__shared_ptr<_Tp>::operator=(std::move(__r)); 00308 return *this; 00309 } 00310 00311 private: 00312 // This constructor is non-standard, it is used by allocate_shared. 00313 template<typename _Alloc, typename... _Args> 00314 shared_ptr(_Sp_make_shared_tag __tag, const _Alloc& __a, 00315 _Args&&... __args) 00316 : __shared_ptr<_Tp>(__tag, __a, std::forward<_Args>(__args)...) 00317 { } 00318 00319 template<typename _Tp1, typename _Alloc, typename... _Args> 00320 friend shared_ptr<_Tp1> 00321 allocate_shared(const _Alloc& __a, _Args&&... __args); 00322 00323 // This constructor is non-standard, it is used by weak_ptr::lock(). 00324 shared_ptr(const weak_ptr<_Tp>& __r, std::nothrow_t) 00325 : __shared_ptr<_Tp>(__r, std::nothrow) { } 00326 00327 friend class weak_ptr<_Tp>; 00328 }; 00329 00330 // 20.7.2.2.7 shared_ptr comparisons 00331 template<typename _Tp1, typename _Tp2> 00332 inline bool 00333 operator==(const shared_ptr<_Tp1>& __a, 00334 const shared_ptr<_Tp2>& __b) noexcept 00335 { return __a.get() == __b.get(); } 00336 00337 template<typename _Tp> 00338 inline bool 00339 operator==(const shared_ptr<_Tp>& __a, nullptr_t) noexcept 00340 { return !__a; } 00341 00342 template<typename _Tp> 00343 inline bool 00344 operator==(nullptr_t, const shared_ptr<_Tp>& __a) noexcept 00345 { return !__a; } 00346 00347 template<typename _Tp1, typename _Tp2> 00348 inline bool 00349 operator!=(const shared_ptr<_Tp1>& __a, 00350 const shared_ptr<_Tp2>& __b) noexcept 00351 { return __a.get() != __b.get(); } 00352 00353 template<typename _Tp> 00354 inline bool 00355 operator!=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept 00356 { return (bool)__a; } 00357 00358 template<typename _Tp> 00359 inline bool 00360 operator!=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept 00361 { return (bool)__a; } 00362 00363 template<typename _Tp1, typename _Tp2> 00364 inline bool 00365 operator<(const shared_ptr<_Tp1>& __a, 00366 const shared_ptr<_Tp2>& __b) noexcept 00367 { 00368 typedef typename std::common_type<_Tp1*, _Tp2*>::type _CT; 00369 return std::less<_CT>()(__a.get(), __b.get()); 00370 } 00371 00372 template<typename _Tp> 00373 inline bool 00374 operator<(const shared_ptr<_Tp>& __a, nullptr_t) noexcept 00375 { return std::less<_Tp*>()(__a.get(), nullptr); } 00376 00377 template<typename _Tp> 00378 inline bool 00379 operator<(nullptr_t, const shared_ptr<_Tp>& __a) noexcept 00380 { return std::less<_Tp*>()(nullptr, __a.get()); } 00381 00382 template<typename _Tp1, typename _Tp2> 00383 inline bool 00384 operator<=(const shared_ptr<_Tp1>& __a, 00385 const shared_ptr<_Tp2>& __b) noexcept 00386 { return !(__b < __a); } 00387 00388 template<typename _Tp> 00389 inline bool 00390 operator<=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept 00391 { return !(nullptr < __a); } 00392 00393 template<typename _Tp> 00394 inline bool 00395 operator<=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept 00396 { return !(__a < nullptr); } 00397 00398 template<typename _Tp1, typename _Tp2> 00399 inline bool 00400 operator>(const shared_ptr<_Tp1>& __a, 00401 const shared_ptr<_Tp2>& __b) noexcept 00402 { return (__b < __a); } 00403 00404 template<typename _Tp> 00405 inline bool 00406 operator>(const shared_ptr<_Tp>& __a, nullptr_t) noexcept 00407 { return std::less<_Tp*>()(nullptr, __a.get()); } 00408 00409 template<typename _Tp> 00410 inline bool 00411 operator>(nullptr_t, const shared_ptr<_Tp>& __a) noexcept 00412 { return std::less<_Tp*>()(__a.get(), nullptr); } 00413 00414 template<typename _Tp1, typename _Tp2> 00415 inline bool 00416 operator>=(const shared_ptr<_Tp1>& __a, 00417 const shared_ptr<_Tp2>& __b) noexcept 00418 { return !(__a < __b); } 00419 00420 template<typename _Tp> 00421 inline bool 00422 operator>=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept 00423 { return !(__a < nullptr); } 00424 00425 template<typename _Tp> 00426 inline bool 00427 operator>=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept 00428 { return !(nullptr < __a); } 00429 00430 template<typename _Tp> 00431 struct less<shared_ptr<_Tp>> : public _Sp_less<shared_ptr<_Tp>> 00432 { }; 00433 00434 // 20.7.2.2.8 shared_ptr specialized algorithms. 00435 template<typename _Tp> 00436 inline void 00437 swap(shared_ptr<_Tp>& __a, shared_ptr<_Tp>& __b) noexcept 00438 { __a.swap(__b); } 00439 00440 // 20.7.2.2.9 shared_ptr casts. 00441 template<typename _Tp, typename _Tp1> 00442 inline shared_ptr<_Tp> 00443 static_pointer_cast(const shared_ptr<_Tp1>& __r) noexcept 00444 { return shared_ptr<_Tp>(__r, static_cast<_Tp*>(__r.get())); } 00445 00446 template<typename _Tp, typename _Tp1> 00447 inline shared_ptr<_Tp> 00448 const_pointer_cast(const shared_ptr<_Tp1>& __r) noexcept 00449 { return shared_ptr<_Tp>(__r, const_cast<_Tp*>(__r.get())); } 00450 00451 template<typename _Tp, typename _Tp1> 00452 inline shared_ptr<_Tp> 00453 dynamic_pointer_cast(const shared_ptr<_Tp1>& __r) noexcept 00454 { 00455 if (_Tp* __p = dynamic_cast<_Tp*>(__r.get())) 00456 return shared_ptr<_Tp>(__r, __p); 00457 return shared_ptr<_Tp>(); 00458 } 00459 00460 00461 /** 00462 * @brief A smart pointer with weak semantics. 00463 * 00464 * With forwarding constructors and assignment operators. 00465 */ 00466 template<typename _Tp> 00467 class weak_ptr : public __weak_ptr<_Tp> 00468 { 00469 public: 00470 constexpr weak_ptr() noexcept 00471 : __weak_ptr<_Tp>() { } 00472 00473 template<typename _Tp1, typename = typename 00474 std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type> 00475 weak_ptr(const weak_ptr<_Tp1>& __r) noexcept 00476 : __weak_ptr<_Tp>(__r) { } 00477 00478 template<typename _Tp1, typename = typename 00479 std::enable_if<std::is_convertible<_Tp1*, _Tp*>::value>::type> 00480 weak_ptr(const shared_ptr<_Tp1>& __r) noexcept 00481 : __weak_ptr<_Tp>(__r) { } 00482 00483 template<typename _Tp1> 00484 weak_ptr& 00485 operator=(const weak_ptr<_Tp1>& __r) noexcept 00486 { 00487 this->__weak_ptr<_Tp>::operator=(__r); 00488 return *this; 00489 } 00490 00491 template<typename _Tp1> 00492 weak_ptr& 00493 operator=(const shared_ptr<_Tp1>& __r) noexcept 00494 { 00495 this->__weak_ptr<_Tp>::operator=(__r); 00496 return *this; 00497 } 00498 00499 shared_ptr<_Tp> 00500 lock() const noexcept 00501 { return shared_ptr<_Tp>(*this, std::nothrow); } 00502 }; 00503 00504 // 20.7.2.3.6 weak_ptr specialized algorithms. 00505 template<typename _Tp> 00506 inline void 00507 swap(weak_ptr<_Tp>& __a, weak_ptr<_Tp>& __b) noexcept 00508 { __a.swap(__b); } 00509 00510 00511 /// Primary template owner_less 00512 template<typename _Tp> 00513 struct owner_less; 00514 00515 /// Partial specialization of owner_less for shared_ptr. 00516 template<typename _Tp> 00517 struct owner_less<shared_ptr<_Tp>> 00518 : public _Sp_owner_less<shared_ptr<_Tp>, weak_ptr<_Tp>> 00519 { }; 00520 00521 /// Partial specialization of owner_less for weak_ptr. 00522 template<typename _Tp> 00523 struct owner_less<weak_ptr<_Tp>> 00524 : public _Sp_owner_less<weak_ptr<_Tp>, shared_ptr<_Tp>> 00525 { }; 00526 00527 /** 00528 * @brief Base class allowing use of member function shared_from_this. 00529 */ 00530 template<typename _Tp> 00531 class enable_shared_from_this 00532 { 00533 protected: 00534 constexpr enable_shared_from_this() noexcept { } 00535 00536 enable_shared_from_this(const enable_shared_from_this&) noexcept { } 00537 00538 enable_shared_from_this& 00539 operator=(const enable_shared_from_this&) noexcept 00540 { return *this; } 00541 00542 ~enable_shared_from_this() { } 00543 00544 public: 00545 shared_ptr<_Tp> 00546 shared_from_this() 00547 { return shared_ptr<_Tp>(this->_M_weak_this); } 00548 00549 shared_ptr<const _Tp> 00550 shared_from_this() const 00551 { return shared_ptr<const _Tp>(this->_M_weak_this); } 00552 00553 private: 00554 template<typename _Tp1> 00555 void 00556 _M_weak_assign(_Tp1* __p, const __shared_count<>& __n) const noexcept 00557 { _M_weak_this._M_assign(__p, __n); } 00558 00559 template<typename _Tp1, typename _Tp2> 00560 friend void 00561 __enable_shared_from_this_helper(const __shared_count<>&, 00562 const enable_shared_from_this<_Tp1>*, 00563 const _Tp2*) noexcept; 00564 00565 mutable weak_ptr<_Tp> _M_weak_this; 00566 }; 00567 00568 template<typename _Tp1, typename _Tp2> 00569 inline void 00570 __enable_shared_from_this_helper(const __shared_count<>& __pn, 00571 const enable_shared_from_this<_Tp1>* 00572 __pe, const _Tp2* __px) noexcept 00573 { 00574 if (__pe != nullptr) 00575 __pe->_M_weak_assign(const_cast<_Tp2*>(__px), __pn); 00576 } 00577 00578 /** 00579 * @brief Create an object that is owned by a shared_ptr. 00580 * @param __a An allocator. 00581 * @param __args Arguments for the @a _Tp object's constructor. 00582 * @return A shared_ptr that owns the newly created object. 00583 * @throw An exception thrown from @a _Alloc::allocate or from the 00584 * constructor of @a _Tp. 00585 * 00586 * A copy of @a __a will be used to allocate memory for the shared_ptr 00587 * and the new object. 00588 */ 00589 template<typename _Tp, typename _Alloc, typename... _Args> 00590 inline shared_ptr<_Tp> 00591 allocate_shared(const _Alloc& __a, _Args&&... __args) 00592 { 00593 return shared_ptr<_Tp>(_Sp_make_shared_tag(), __a, 00594 std::forward<_Args>(__args)...); 00595 } 00596 00597 /** 00598 * @brief Create an object that is owned by a shared_ptr. 00599 * @param __args Arguments for the @a _Tp object's constructor. 00600 * @return A shared_ptr that owns the newly created object. 00601 * @throw std::bad_alloc, or an exception thrown from the 00602 * constructor of @a _Tp. 00603 */ 00604 template<typename _Tp, typename... _Args> 00605 inline shared_ptr<_Tp> 00606 make_shared(_Args&&... __args) 00607 { 00608 typedef typename std::remove_const<_Tp>::type _Tp_nc; 00609 return std::allocate_shared<_Tp>(std::allocator<_Tp_nc>(), 00610 std::forward<_Args>(__args)...); 00611 } 00612 00613 /// std::hash specialization for shared_ptr. 00614 template<typename _Tp> 00615 struct hash<shared_ptr<_Tp>> 00616 : public __hash_base<size_t, shared_ptr<_Tp>> 00617 { 00618 size_t 00619 operator()(const shared_ptr<_Tp>& __s) const noexcept 00620 { return std::hash<_Tp*>()(__s.get()); } 00621 }; 00622 00623 // @} group pointer_abstractions 00624 00625 _GLIBCXX_END_NAMESPACE_VERSION 00626 } // namespace 00627 00628 #endif // _SHARED_PTR_H