1 // shared_ptr and weak_ptr implementation -*- C++ -*- 2 3 // Copyright (C) 2007, 2008, 2009 Free Software Foundation, Inc. 4 // 5 // This file is part of the GNU ISO C++ Library. This library is free 6 // software; you can redistribute it and/or modify it under the 7 // terms of the GNU General Public License as published by the 8 // Free Software Foundation; either version 3, or (at your option) 9 // any later version. 10 11 // This library is distributed in the hope that it will be useful, 12 // but WITHOUT ANY WARRANTY; without even the implied warranty of 13 // MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the 14 // GNU General Public License for more details. 15 16 // Under Section 7 of GPL version 3, you are granted additional 17 // permissions described in the GCC Runtime Library Exception, version 18 // 3.1, as published by the Free Software Foundation. 19 20 // You should have received a copy of the GNU General Public License and 21 // a copy of the GCC Runtime Library Exception along with this program; 22 // see the files COPYING3 and COPYING.RUNTIME respectively. If not, see 23 // <http://www.gnu.org/licenses/>. 24 25 // shared_count.hpp 26 // Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd. 27 28 // shared_ptr.hpp 29 // Copyright (C) 1998, 1999 Greg Colvin and Beman Dawes. 30 // Copyright (C) 2001, 2002, 2003 Peter Dimov 31 32 // weak_ptr.hpp 33 // Copyright (C) 2001, 2002, 2003 Peter Dimov 34 35 // enable_shared_from_this.hpp 36 // Copyright (C) 2002 Peter Dimov 37 38 // Distributed under the Boost Software License, Version 1.0. (See 39 // accompanying file LICENSE_1_0.txt or copy at 40 // http://www.boost.org/LICENSE_1_0.txt) 41 42 // GCC Note: based on version 1.32.0 of the Boost library. 43 44 /** @file bits/shared_ptr.h 45 * This is an internal header file, included by other library headers. 46 * You should not attempt to use it directly. 47 */ 48 49 #ifndef _SHARED_PTR_H 50 #define _SHARED_PTR_H 1 51 52 #ifndef __GXX_EXPERIMENTAL_CXX0X__ 53 # include <c++0x_warning.h> 54 #endif 55 56 #if defined(_GLIBCXX_INCLUDE_AS_TR1) 57 # error C++0x header cannot be included from TR1 header 58 #endif 59 60 _GLIBCXX_BEGIN_NAMESPACE(std) 61 62 /** 63 * @addtogroup pointer_abstractions 64 * @{ 65 */ 66 67 // counted ptr with no deleter or allocator support 68 template<typename _Ptr, _Lock_policy _Lp> 69 class _Sp_counted_ptr 70 : public _Sp_counted_base<_Lp> 71 { 72 public: 73 _Sp_counted_ptr(_Ptr __p) 74 : _M_ptr(__p) { } 75 76 virtual void 77 _M_dispose() // nothrow 78 { delete _M_ptr; } 79 80 virtual void 81 _M_destroy() // nothrow 82 { delete this; } 83 84 virtual void* 85 _M_get_deleter(const std::type_info& __ti) 86 { return 0; } 87 88 _Sp_counted_ptr(const _Sp_counted_ptr&) = delete; 89 _Sp_counted_ptr& operator=(const _Sp_counted_ptr&) = delete; 90 91 protected: 92 _Ptr _M_ptr; // copy constructor must not throw 93 }; 94 95 // support for custom deleter and/or allocator 96 template<typename _Ptr, typename _Deleter, typename _Alloc, _Lock_policy _Lp> 97 class _Sp_counted_deleter 98 : public _Sp_counted_ptr<_Ptr, _Lp> 99 { 100 typedef typename _Alloc::template 101 rebind<_Sp_counted_deleter>::other _My_alloc_type; 102 103 // Helper class that stores the Deleter and also acts as an allocator. 104 // Used to dispose of the owned pointer and the internal refcount 105 // Requires that copies of _Alloc can free each other's memory. 106 struct _My_Deleter 107 : public _My_alloc_type // copy constructor must not throw 108 { 109 _Deleter _M_del; // copy constructor must not throw 110 _My_Deleter(_Deleter __d, const _Alloc& __a) 111 : _My_alloc_type(__a), _M_del(__d) { } 112 }; 113 114 protected: 115 typedef _Sp_counted_ptr<_Ptr, _Lp> _Base_type; 116 117 public: 118 /** 119 * @brief 120 * @pre __d(__p) must not throw. 121 */ 122 _Sp_counted_deleter(_Ptr __p, _Deleter __d) 123 : _Base_type(__p), _M_del(__d, _Alloc()) { } 124 125 /** 126 * @brief 127 * @pre __d(__p) must not throw. 128 */ 129 _Sp_counted_deleter(_Ptr __p, _Deleter __d, const _Alloc& __a) 130 : _Base_type(__p), _M_del(__d, __a) { } 131 132 virtual void 133 _M_dispose() // nothrow 134 { _M_del._M_del(_Base_type::_M_ptr); } 135 136 virtual void 137 _M_destroy() // nothrow 138 { 139 _My_alloc_type __a(_M_del); 140 this->~_Sp_counted_deleter(); 141 __a.deallocate(this, 1); 142 } 143 144 virtual void* 145 _M_get_deleter(const std::type_info& __ti) 146 { return __ti == typeid(_Deleter) ? &_M_del._M_del : 0; } 147 148 protected: 149 _My_Deleter _M_del; // copy constructor must not throw 150 }; 151 152 // helpers for make_shared / allocate_shared 153 154 template<typename _Tp> 155 struct _Sp_destroy_inplace 156 { 157 void operator()(_Tp* __p) const { if (__p) __p->~_Tp(); } 158 }; 159 160 struct _Sp_make_shared_tag { }; 161 162 template<typename _Tp, typename _Alloc, _Lock_policy _Lp> 163 class _Sp_counted_ptr_inplace 164 : public _Sp_counted_deleter<_Tp*, _Sp_destroy_inplace<_Tp>, _Alloc, _Lp> 165 { 166 typedef _Sp_counted_deleter<_Tp*, _Sp_destroy_inplace<_Tp>, _Alloc, _Lp> 167 _Base_type; 168 169 public: 170 _Sp_counted_ptr_inplace(_Alloc __a) 171 : _Base_type(static_cast<_Tp*>(0), _Sp_destroy_inplace<_Tp>(), __a) 172 , _M_storage() 173 { 174 void* __p = &_M_storage; 175 ::new (__p) _Tp(); // might throw 176 _Base_type::_Base_type::_M_ptr = static_cast<_Tp*>(__p); 177 } 178 179 template<typename... _Args> 180 _Sp_counted_ptr_inplace(_Alloc __a, _Args&&... __args) 181 : _Base_type(static_cast<_Tp*>(0), _Sp_destroy_inplace<_Tp>(), __a) 182 , _M_storage() 183 { 184 void* __p = &_M_storage; 185 ::new (__p) _Tp(std::forward<_Args>(__args)...); // might throw 186 _Base_type::_Base_type::_M_ptr = static_cast<_Tp*>(__p); 187 } 188 189 // override because the allocator needs to know the dynamic type 190 virtual void 191 _M_destroy() // nothrow 192 { 193 typedef typename _Alloc::template 194 rebind<_Sp_counted_ptr_inplace>::other _My_alloc_type; 195 _My_alloc_type __a(_Base_type::_M_del); 196 this->~_Sp_counted_ptr_inplace(); 197 __a.deallocate(this, 1); 198 } 199 200 // sneaky trick so __shared_ptr can get the managed pointer 201 virtual void* 202 _M_get_deleter(const std::type_info& __ti) 203 { 204 return __ti == typeid(_Sp_make_shared_tag) 205 ? static_cast<void*>(&_M_storage) 206 : _Base_type::_M_get_deleter(__ti); 207 } 208 209 private: 210 typename aligned_storage<sizeof(_Tp), alignment_of<_Tp>::value>::type 211 _M_storage; 212 }; 213 214 template<_Lock_policy _Lp = __default_lock_policy> 215 class __weak_count; 216 217 template<_Lock_policy _Lp = __default_lock_policy> 218 class __shared_count 219 { 220 public: 221 __shared_count() 222 : _M_pi(0) // nothrow 223 { } 224 225 template<typename _Ptr> 226 __shared_count(_Ptr __p) : _M_pi(0) 227 { 228 __try 229 { 230 _M_pi = new _Sp_counted_ptr<_Ptr, _Lp>(__p); 231 } 232 __catch(...) 233 { 234 delete __p; 235 __throw_exception_again; 236 } 237 } 238 239 template<typename _Ptr, typename _Deleter> 240 __shared_count(_Ptr __p, _Deleter __d) : _M_pi(0) 241 { 242 // allocator's value_type doesn't matter, will rebind it anyway 243 typedef std::allocator<int> _Alloc; 244 typedef _Sp_counted_deleter<_Ptr, _Deleter, _Alloc, _Lp> _Sp_cd_type; 245 typedef std::allocator<_Sp_cd_type> _Alloc2; 246 _Alloc2 __a2; 247 __try 248 { 249 _M_pi = __a2.allocate(1); 250 ::new(static_cast<void*>(_M_pi)) _Sp_cd_type(__p, __d); 251 } 252 __catch(...) 253 { 254 __d(__p); // Call _Deleter on __p. 255 if (_M_pi) 256 __a2.deallocate(static_cast<_Sp_cd_type*>(_M_pi), 1); 257 __throw_exception_again; 258 } 259 } 260 261 template<typename _Ptr, typename _Deleter, typename _Alloc> 262 __shared_count(_Ptr __p, _Deleter __d, _Alloc __a) : _M_pi(0) 263 { 264 typedef _Sp_counted_deleter<_Ptr, _Deleter, _Alloc, _Lp> _Sp_cd_type; 265 typedef typename _Alloc::template rebind<_Sp_cd_type>::other _Alloc2; 266 _Alloc2 __a2(__a); 267 __try 268 { 269 _M_pi = __a2.allocate(1); 270 ::new(static_cast<void*>(_M_pi)) _Sp_cd_type(__p, __d, __a); 271 } 272 __catch(...) 273 { 274 __d(__p); // Call _Deleter on __p. 275 if (_M_pi) 276 __a2.deallocate(static_cast<_Sp_cd_type*>(_M_pi), 1); 277 __throw_exception_again; 278 } 279 } 280 281 template<typename _Tp, typename _Alloc, typename... _Args> 282 __shared_count(_Sp_make_shared_tag, _Tp*, _Alloc __a, _Args&&... __args) 283 : _M_pi(0) 284 { 285 typedef _Sp_counted_ptr_inplace<_Tp, _Alloc, _Lp> _Sp_cp_type; 286 typedef typename _Alloc::template rebind<_Sp_cp_type>::other _Alloc2; 287 _Alloc2 __a2(__a); 288 __try 289 { 290 _M_pi = __a2.allocate(1); 291 ::new(static_cast<void*>(_M_pi)) _Sp_cp_type(__a, 292 std::forward<_Args>(__args)...); 293 } 294 __catch(...) 295 { 296 if (_M_pi) 297 __a2.deallocate(static_cast<_Sp_cp_type*>(_M_pi), 1); 298 __throw_exception_again; 299 } 300 } 301 302 #if _GLIBCXX_DEPRECATED 303 // Special case for auto_ptr<_Tp> to provide the strong guarantee. 304 template<typename _Tp> 305 explicit 306 __shared_count(std::auto_ptr<_Tp>&& __r) 307 : _M_pi(new _Sp_counted_ptr<_Tp*, _Lp>(__r.get())) 308 { __r.release(); } 309 #endif 310 311 // Special case for unique_ptr<_Tp,_Del> to provide the strong guarantee. 312 template<typename _Tp, typename _Del> 313 explicit 314 __shared_count(std::unique_ptr<_Tp, _Del>&& __r) 315 : _M_pi(_S_create_from_up(std::move(__r))) 316 { __r.release(); } 317 318 // Throw bad_weak_ptr when __r._M_get_use_count() == 0. 319 explicit 320 __shared_count(const __weak_count<_Lp>& __r); 321 322 ~__shared_count() // nothrow 323 { 324 if (_M_pi != 0) 325 _M_pi->_M_release(); 326 } 327 328 __shared_count(const __shared_count& __r) 329 : _M_pi(__r._M_pi) // nothrow 330 { 331 if (_M_pi != 0) 332 _M_pi->_M_add_ref_copy(); 333 } 334 335 __shared_count& 336 operator=(const __shared_count& __r) // nothrow 337 { 338 _Sp_counted_base<_Lp>* __tmp = __r._M_pi; 339 if (__tmp != _M_pi) 340 { 341 if (__tmp != 0) 342 __tmp->_M_add_ref_copy(); 343 if (_M_pi != 0) 344 _M_pi->_M_release(); 345 _M_pi = __tmp; 346 } 347 return *this; 348 } 349 350 void 351 _M_swap(__shared_count& __r) // nothrow 352 { 353 _Sp_counted_base<_Lp>* __tmp = __r._M_pi; 354 __r._M_pi = _M_pi; 355 _M_pi = __tmp; 356 } 357 358 long 359 _M_get_use_count() const // nothrow 360 { return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0; } 361 362 bool 363 _M_unique() const // nothrow 364 { return this->_M_get_use_count() == 1; } 365 366 void* 367 _M_get_deleter(const std::type_info& __ti) const 368 { return _M_pi ? _M_pi->_M_get_deleter(__ti) : 0; } 369 370 bool 371 _M_less(const __shared_count& __rhs) const 372 { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); } 373 374 bool 375 _M_less(const __weak_count<_Lp>& __rhs) const 376 { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); } 377 378 // friend function injected into enclosing namespace and found by ADL 379 friend inline bool 380 operator==(const __shared_count& __a, const __shared_count& __b) 381 { return __a._M_pi == __b._M_pi; } 382 383 private: 384 friend class __weak_count<_Lp>; 385 386 template<typename _Tp, typename _Del> 387 static _Sp_counted_base<_Lp>* 388 _S_create_from_up(std::unique_ptr<_Tp, _Del>&& __r, 389 typename std::enable_if<!std::is_reference<_Del>::value>::type* = 0) 390 { 391 return new _Sp_counted_deleter<_Tp*, _Del, std::allocator<_Tp>, 392 _Lp>(__r.get(), __r.get_deleter()); 393 } 394 395 template<typename _Tp, typename _Del> 396 static _Sp_counted_base<_Lp>* 397 _S_create_from_up(std::unique_ptr<_Tp, _Del>&& __r, 398 typename std::enable_if<std::is_reference<_Del>::value>::type* = 0) 399 { 400 typedef typename std::remove_reference<_Del>::type _Del1; 401 typedef std::reference_wrapper<_Del1> _Del2; 402 return new _Sp_counted_deleter<_Tp*, _Del2, std::allocator<_Tp>, 403 _Lp>(__r.get(), std::ref(__r.get_deleter())); 404 } 405 406 _Sp_counted_base<_Lp>* _M_pi; 407 }; 408 409 410 template<_Lock_policy _Lp> 411 class __weak_count 412 { 413 public: 414 __weak_count() 415 : _M_pi(0) // nothrow 416 { } 417 418 __weak_count(const __shared_count<_Lp>& __r) 419 : _M_pi(__r._M_pi) // nothrow 420 { 421 if (_M_pi != 0) 422 _M_pi->_M_weak_add_ref(); 423 } 424 425 __weak_count(const __weak_count<_Lp>& __r) 426 : _M_pi(__r._M_pi) // nothrow 427 { 428 if (_M_pi != 0) 429 _M_pi->_M_weak_add_ref(); 430 } 431 432 ~__weak_count() // nothrow 433 { 434 if (_M_pi != 0) 435 _M_pi->_M_weak_release(); 436 } 437 438 __weak_count<_Lp>& 439 operator=(const __shared_count<_Lp>& __r) // nothrow 440 { 441 _Sp_counted_base<_Lp>* __tmp = __r._M_pi; 442 if (__tmp != 0) 443 __tmp->_M_weak_add_ref(); 444 if (_M_pi != 0) 445 _M_pi->_M_weak_release(); 446 _M_pi = __tmp; 447 return *this; 448 } 449 450 __weak_count<_Lp>& 451 operator=(const __weak_count<_Lp>& __r) // nothrow 452 { 453 _Sp_counted_base<_Lp>* __tmp = __r._M_pi; 454 if (__tmp != 0) 455 __tmp->_M_weak_add_ref(); 456 if (_M_pi != 0) 457 _M_pi->_M_weak_release(); 458 _M_pi = __tmp; 459 return *this; 460 } 461 462 void 463 _M_swap(__weak_count<_Lp>& __r) // nothrow 464 { 465 _Sp_counted_base<_Lp>* __tmp = __r._M_pi; 466 __r._M_pi = _M_pi; 467 _M_pi = __tmp; 468 } 469 470 long 471 _M_get_use_count() const // nothrow 472 { return _M_pi != 0 ? _M_pi->_M_get_use_count() : 0; } 473 474 bool 475 _M_less(const __weak_count& __rhs) const 476 { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); } 477 478 bool 479 _M_less(const __shared_count<_Lp>& __rhs) const 480 { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); } 481 482 // friend function injected into enclosing namespace and found by ADL 483 friend inline bool 484 operator==(const __weak_count& __a, const __weak_count& __b) 485 { return __a._M_pi == __b._M_pi; } 486 487 private: 488 friend class __shared_count<_Lp>; 489 490 _Sp_counted_base<_Lp>* _M_pi; 491 }; 492 493 // now that __weak_count is defined we can define this constructor: 494 template<_Lock_policy _Lp> 495 inline 496 __shared_count<_Lp>:: 497 __shared_count(const __weak_count<_Lp>& __r) 498 : _M_pi(__r._M_pi) 499 { 500 if (_M_pi != 0) 501 _M_pi->_M_add_ref_lock(); 502 else 503 __throw_bad_weak_ptr(); 504 } 505 506 // Forward declarations. 507 template<typename _Tp, _Lock_policy _Lp = __default_lock_policy> 508 class __shared_ptr; 509 510 template<typename _Tp, _Lock_policy _Lp = __default_lock_policy> 511 class __weak_ptr; 512 513 template<typename _Tp, _Lock_policy _Lp = __default_lock_policy> 514 class __enable_shared_from_this; 515 516 template<typename _Tp> 517 class shared_ptr; 518 519 template<typename _Tp> 520 class weak_ptr; 521 522 template<typename _Tp> 523 class enable_shared_from_this; 524 525 // Support for enable_shared_from_this. 526 527 // Friend of __enable_shared_from_this. 528 template<_Lock_policy _Lp, typename _Tp1, typename _Tp2> 529 void 530 __enable_shared_from_this_helper(const __shared_count<_Lp>&, 531 const __enable_shared_from_this<_Tp1, 532 _Lp>*, const _Tp2*); 533 534 // Friend of enable_shared_from_this. 535 template<typename _Tp1, typename _Tp2> 536 void 537 __enable_shared_from_this_helper(const __shared_count<>&, 538 const enable_shared_from_this<_Tp1>*, 539 const _Tp2*); 540 541 template<_Lock_policy _Lp> 542 inline void 543 __enable_shared_from_this_helper(const __shared_count<_Lp>&, ...) 544 { } 545 546 547 template<typename _Tp, _Lock_policy _Lp> 548 class __shared_ptr 549 { 550 public: 551 typedef _Tp element_type; 552 553 /** @brief Construct an empty %__shared_ptr. 554 * @post use_count()==0 && get()==0 555 */ 556 __shared_ptr() 557 : _M_ptr(0), _M_refcount() // never throws 558 { } 559 560 /** @brief Construct a %__shared_ptr that owns the pointer @a __p. 561 * @param __p A pointer that is convertible to element_type*. 562 * @post use_count() == 1 && get() == __p 563 * @throw std::bad_alloc, in which case @c delete @a __p is called. 564 */ 565 template<typename _Tp1> 566 explicit 567 __shared_ptr(_Tp1* __p) 568 : _M_ptr(__p), _M_refcount(__p) 569 { 570 __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) 571 // __glibcxx_function_requires(_CompleteConcept<_Tp1*>) 572 __enable_shared_from_this_helper(_M_refcount, __p, __p); 573 } 574 575 // 576 // Requirements: _Deleter's copy constructor and destructor must 577 // not throw 578 // 579 // __shared_ptr will release __p by calling __d(__p) 580 // 581 /** @brief Construct a %__shared_ptr that owns the pointer @a __p 582 * and the deleter @a __d. 583 * @param __p A pointer. 584 * @param __d A deleter. 585 * @post use_count() == 1 && get() == __p 586 * @throw std::bad_alloc, in which case @a __d(__p) is called. 587 */ 588 template<typename _Tp1, typename _Deleter> 589 __shared_ptr(_Tp1* __p, _Deleter __d) 590 : _M_ptr(__p), _M_refcount(__p, __d) 591 { 592 __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) 593 // TODO requires _Deleter CopyConstructible and __d(__p) well-formed 594 __enable_shared_from_this_helper(_M_refcount, __p, __p); 595 } 596 597 // 598 // Requirements: _Deleter's copy constructor and destructor must 599 // not throw _Alloc's copy constructor and destructor must not 600 // throw. 601 // 602 // __shared_ptr will release __p by calling __d(__p) 603 // 604 /** @brief Construct a %__shared_ptr that owns the pointer @a __p 605 * and the deleter @a __d. 606 * @param __p A pointer. 607 * @param __d A deleter. 608 * @param __a An allocator. 609 * @post use_count() == 1 && get() == __p 610 * @throw std::bad_alloc, in which case @a __d(__p) is called. 611 */ 612 template<typename _Tp1, typename _Deleter, typename _Alloc> 613 __shared_ptr(_Tp1* __p, _Deleter __d, const _Alloc& __a) 614 : _M_ptr(__p), _M_refcount(__p, __d, __a) 615 { 616 __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) 617 // TODO requires _Deleter CopyConstructible and __d(__p) well-formed 618 __enable_shared_from_this_helper(_M_refcount, __p, __p); 619 } 620 621 /** @brief Constructs a %__shared_ptr instance that stores @a __p 622 * and shares ownership with @a __r. 623 * @param __r A %__shared_ptr. 624 * @param __p A pointer that will remain valid while @a *__r is valid. 625 * @post get() == __p && use_count() == __r.use_count() 626 * 627 * This can be used to construct a @c shared_ptr to a sub-object 628 * of an object managed by an existing @c shared_ptr. 629 * 630 * @code 631 * shared_ptr< pair<int,int> > pii(new pair<int,int>()); 632 * shared_ptr<int> pi(pii, &pii->first); 633 * assert(pii.use_count() == 2); 634 * @endcode 635 */ 636 template<typename _Tp1> 637 __shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r, _Tp* __p) 638 : _M_ptr(__p), _M_refcount(__r._M_refcount) // never throws 639 { } 640 641 // generated copy constructor, assignment, destructor are fine. 642 643 /** @brief If @a __r is empty, constructs an empty %__shared_ptr; 644 * otherwise construct a %__shared_ptr that shares ownership 645 * with @a __r. 646 * @param __r A %__shared_ptr. 647 * @post get() == __r.get() && use_count() == __r.use_count() 648 */ 649 template<typename _Tp1> 650 __shared_ptr(const __shared_ptr<_Tp1, _Lp>& __r) 651 : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) // never throws 652 { __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) } 653 654 /** @brief Move-constructs a %__shared_ptr instance from @a __r. 655 * @param __r A %__shared_ptr rvalue. 656 * @post *this contains the old value of @a __r, @a __r is empty. 657 */ 658 __shared_ptr(__shared_ptr&& __r) 659 : _M_ptr(__r._M_ptr), _M_refcount() // never throws 660 { 661 _M_refcount._M_swap(__r._M_refcount); 662 __r._M_ptr = 0; 663 } 664 665 /** @brief Move-constructs a %__shared_ptr instance from @a __r. 666 * @param __r A %__shared_ptr rvalue. 667 * @post *this contains the old value of @a __r, @a __r is empty. 668 */ 669 template<typename _Tp1> 670 __shared_ptr(__shared_ptr<_Tp1, _Lp>&& __r) 671 : _M_ptr(__r._M_ptr), _M_refcount() // never throws 672 { 673 __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) 674 _M_refcount._M_swap(__r._M_refcount); 675 __r._M_ptr = 0; 676 } 677 678 /** @brief Constructs a %__shared_ptr that shares ownership with @a __r 679 * and stores a copy of the pointer stored in @a __r. 680 * @param __r A weak_ptr. 681 * @post use_count() == __r.use_count() 682 * @throw bad_weak_ptr when __r.expired(), 683 * in which case the constructor has no effect. 684 */ 685 template<typename _Tp1> 686 explicit 687 __shared_ptr(const __weak_ptr<_Tp1, _Lp>& __r) 688 : _M_refcount(__r._M_refcount) // may throw 689 { 690 __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) 691 // It is now safe to copy __r._M_ptr, as _M_refcount(__r._M_refcount) 692 // did not throw. 693 _M_ptr = __r._M_ptr; 694 } 695 696 template<typename _Tp1, typename _Del> 697 explicit 698 __shared_ptr(const std::unique_ptr<_Tp1, _Del>&) = delete; 699 700 /** 701 * If an exception is thrown this constructor has no effect. 702 */ 703 template<typename _Tp1, typename _Del> 704 explicit 705 __shared_ptr(std::unique_ptr<_Tp1, _Del>&& __r) 706 : _M_ptr(__r.get()), _M_refcount() 707 { 708 __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) 709 _Tp1* __tmp = __r.get(); 710 _M_refcount = __shared_count<_Lp>(std::move(__r)); 711 __enable_shared_from_this_helper(_M_refcount, __tmp, __tmp); 712 } 713 714 #if _GLIBCXX_DEPRECATED 715 /** 716 * @post use_count() == 1 and __r.get() == 0 717 */ 718 template<typename _Tp1> 719 explicit 720 __shared_ptr(std::auto_ptr<_Tp1>&& __r) 721 : _M_ptr(__r.get()), _M_refcount() 722 { 723 __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) 724 // TODO requires _Tp1 is complete, delete __r.release() well-formed 725 _Tp1* __tmp = __r.get(); 726 _M_refcount = __shared_count<_Lp>(std::move(__r)); 727 __enable_shared_from_this_helper(_M_refcount, __tmp, __tmp); 728 } 729 #endif 730 731 template<typename _Tp1> 732 __shared_ptr& 733 operator=(const __shared_ptr<_Tp1, _Lp>& __r) // never throws 734 { 735 _M_ptr = __r._M_ptr; 736 _M_refcount = __r._M_refcount; // __shared_count::op= doesn't throw 737 return *this; 738 } 739 740 #if _GLIBCXX_DEPRECATED 741 template<typename _Tp1> 742 __shared_ptr& 743 operator=(std::auto_ptr<_Tp1>&& __r) 744 { 745 __shared_ptr(std::move(__r)).swap(*this); 746 return *this; 747 } 748 #endif 749 750 __shared_ptr& 751 operator=(__shared_ptr&& __r) 752 { 753 __shared_ptr(std::move(__r)).swap(*this); 754 return *this; 755 } 756 757 template<class _Tp1> 758 __shared_ptr& 759 operator=(__shared_ptr<_Tp1, _Lp>&& __r) 760 { 761 __shared_ptr(std::move(__r)).swap(*this); 762 return *this; 763 } 764 765 template<typename _Tp1, typename _Del> 766 __shared_ptr& 767 operator=(const std::unique_ptr<_Tp1, _Del>& __r) = delete; 768 769 template<typename _Tp1, typename _Del> 770 __shared_ptr& 771 operator=(std::unique_ptr<_Tp1, _Del>&& __r) 772 { 773 __shared_ptr(std::move(__r)).swap(*this); 774 return *this; 775 } 776 777 void 778 reset() // never throws 779 { __shared_ptr().swap(*this); } 780 781 template<typename _Tp1> 782 void 783 reset(_Tp1* __p) // _Tp1 must be complete. 784 { 785 // Catch self-reset errors. 786 _GLIBCXX_DEBUG_ASSERT(__p == 0 || __p != _M_ptr); 787 __shared_ptr(__p).swap(*this); 788 } 789 790 template<typename _Tp1, typename _Deleter> 791 void 792 reset(_Tp1* __p, _Deleter __d) 793 { __shared_ptr(__p, __d).swap(*this); } 794 795 template<typename _Tp1, typename _Deleter, typename _Alloc> 796 void 797 reset(_Tp1* __p, _Deleter __d, const _Alloc& __a) 798 { __shared_ptr(__p, __d, __a).swap(*this); } 799 800 // Allow class instantiation when _Tp is [cv-qual] void. 801 typename std::add_lvalue_reference<_Tp>::type 802 operator*() const // never throws 803 { 804 _GLIBCXX_DEBUG_ASSERT(_M_ptr != 0); 805 return *_M_ptr; 806 } 807 808 _Tp* 809 operator->() const // never throws 810 { 811 _GLIBCXX_DEBUG_ASSERT(_M_ptr != 0); 812 return _M_ptr; 813 } 814 815 _Tp* 816 get() const // never throws 817 { return _M_ptr; } 818 819 // Implicit conversion to "bool" 820 private: 821 typedef _Tp* __shared_ptr::*__unspecified_bool_type; 822 823 public: 824 operator __unspecified_bool_type() const // never throws 825 { return _M_ptr == 0 ? 0 : &__shared_ptr::_M_ptr; } 826 827 bool 828 unique() const // never throws 829 { return _M_refcount._M_unique(); } 830 831 long 832 use_count() const // never throws 833 { return _M_refcount._M_get_use_count(); } 834 835 void 836 swap(__shared_ptr<_Tp, _Lp>& __other) // never throws 837 { 838 std::swap(_M_ptr, __other._M_ptr); 839 _M_refcount._M_swap(__other._M_refcount); 840 } 841 842 template<typename _Tp1> 843 bool 844 owner_before(__shared_ptr<_Tp1, _Lp> const& __rhs) const 845 { return _M_refcount._M_less(__rhs._M_refcount); } 846 847 template<typename _Tp1> 848 bool 849 owner_before(__weak_ptr<_Tp1, _Lp> const& __rhs) const 850 { return _M_refcount._M_less(__rhs._M_refcount); } 851 852 protected: 853 // This constructor is non-standard, it is used by allocate_shared. 854 template<typename _Alloc, typename... _Args> 855 __shared_ptr(_Sp_make_shared_tag __tag, _Alloc __a, _Args&&... __args) 856 : _M_ptr(), _M_refcount(__tag, (_Tp*)0, __a, 857 std::forward<_Args>(__args)...) 858 { 859 // _M_ptr needs to point to the newly constructed object. 860 // This relies on _Sp_counted_ptr_inplace::_M_get_deleter. 861 void* __p = _M_refcount._M_get_deleter(typeid(__tag)); 862 _M_ptr = static_cast<_Tp*>(__p); 863 __enable_shared_from_this_helper(_M_refcount, _M_ptr, _M_ptr); 864 } 865 866 template<typename _Tp1, _Lock_policy _Lp1, typename _Alloc, 867 typename... _Args> 868 friend __shared_ptr<_Tp1, _Lp1> 869 __allocate_shared(_Alloc __a, _Args&&... __args); 870 871 private: 872 void* 873 _M_get_deleter(const std::type_info& __ti) const 874 { return _M_refcount._M_get_deleter(__ti); } 875 876 template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr; 877 template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr; 878 879 template<typename _Del, typename _Tp1, _Lock_policy _Lp1> 880 friend _Del* get_deleter(const __shared_ptr<_Tp1, _Lp1>&); 881 882 _Tp* _M_ptr; // Contained pointer. 883 __shared_count<_Lp> _M_refcount; // Reference counter. 884 }; 885 886 // 20.8.13.2.7 shared_ptr comparisons 887 template<typename _Tp1, typename _Tp2, _Lock_policy _Lp> 888 inline bool 889 operator==(const __shared_ptr<_Tp1, _Lp>& __a, 890 const __shared_ptr<_Tp2, _Lp>& __b) 891 { return __a.get() == __b.get(); } 892 893 template<typename _Tp1, typename _Tp2, _Lock_policy _Lp> 894 inline bool 895 operator!=(const __shared_ptr<_Tp1, _Lp>& __a, 896 const __shared_ptr<_Tp2, _Lp>& __b) 897 { return __a.get() != __b.get(); } 898 899 template<typename _Tp1, typename _Tp2, _Lock_policy _Lp> 900 inline bool 901 operator<(const __shared_ptr<_Tp1, _Lp>& __a, 902 const __shared_ptr<_Tp2, _Lp>& __b) 903 { return __a.get() < __b.get(); } 904 905 template<typename _Sp> 906 struct _Sp_less : public binary_function<_Sp, _Sp, bool> 907 { 908 bool 909 operator()(const _Sp& __lhs, const _Sp& __rhs) const 910 { 911 return std::less<typename _Sp::element_type*>()(__lhs.get(), 912 __rhs.get()); 913 } 914 }; 915 916 template<typename _Tp, _Lock_policy _Lp> 917 struct less<__shared_ptr<_Tp, _Lp>> 918 : public _Sp_less<__shared_ptr<_Tp, _Lp>> 919 { }; 920 921 // XXX LessThanComparable<_Tp> concept should provide >, >= and <= 922 template<typename _Tp, _Lock_policy _Lp> 923 inline bool 924 operator>(const __shared_ptr<_Tp, _Lp>& __a, 925 const __shared_ptr<_Tp, _Lp>& __b) 926 { return __a.get() > __b.get(); } 927 928 template<typename _Tp, _Lock_policy _Lp> 929 inline bool 930 operator>=(const __shared_ptr<_Tp, _Lp>& __a, 931 const __shared_ptr<_Tp, _Lp>& __b) 932 { return __a.get() >= __b.get(); } 933 934 template<typename _Tp, _Lock_policy _Lp> 935 inline bool 936 operator<=(const __shared_ptr<_Tp, _Lp>& __a, 937 const __shared_ptr<_Tp, _Lp>& __b) 938 { return __a.get() <= __b.get(); } 939 940 // 2.2.3.8 shared_ptr specialized algorithms. 941 template<typename _Tp, _Lock_policy _Lp> 942 inline void 943 swap(__shared_ptr<_Tp, _Lp>& __a, __shared_ptr<_Tp, _Lp>& __b) 944 { __a.swap(__b); } 945 946 // 2.2.3.9 shared_ptr casts 947 /** @warning The seemingly equivalent 948 * <code>shared_ptr<_Tp, _Lp>(static_cast<_Tp*>(__r.get()))</code> 949 * will eventually result in undefined behaviour, 950 * attempting to delete the same object twice. 951 */ 952 template<typename _Tp, typename _Tp1, _Lock_policy _Lp> 953 inline __shared_ptr<_Tp, _Lp> 954 static_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) 955 { return __shared_ptr<_Tp, _Lp>(__r, static_cast<_Tp*>(__r.get())); } 956 957 /** @warning The seemingly equivalent 958 * <code>shared_ptr<_Tp, _Lp>(const_cast<_Tp*>(__r.get()))</code> 959 * will eventually result in undefined behaviour, 960 * attempting to delete the same object twice. 961 */ 962 template<typename _Tp, typename _Tp1, _Lock_policy _Lp> 963 inline __shared_ptr<_Tp, _Lp> 964 const_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) 965 { return __shared_ptr<_Tp, _Lp>(__r, const_cast<_Tp*>(__r.get())); } 966 967 /** @warning The seemingly equivalent 968 * <code>shared_ptr<_Tp, _Lp>(dynamic_cast<_Tp*>(__r.get()))</code> 969 * will eventually result in undefined behaviour, 970 * attempting to delete the same object twice. 971 */ 972 template<typename _Tp, typename _Tp1, _Lock_policy _Lp> 973 inline __shared_ptr<_Tp, _Lp> 974 dynamic_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) 975 { 976 if (_Tp* __p = dynamic_cast<_Tp*>(__r.get())) 977 return __shared_ptr<_Tp, _Lp>(__r, __p); 978 return __shared_ptr<_Tp, _Lp>(); 979 } 980 981 // 2.2.3.7 shared_ptr I/O 982 template<typename _Ch, typename _Tr, typename _Tp, _Lock_policy _Lp> 983 std::basic_ostream<_Ch, _Tr>& 984 operator<<(std::basic_ostream<_Ch, _Tr>& __os, 985 const __shared_ptr<_Tp, _Lp>& __p) 986 { 987 __os << __p.get(); 988 return __os; 989 } 990 991 // 2.2.3.10 shared_ptr get_deleter (experimental) 992 template<typename _Del, typename _Tp, _Lock_policy _Lp> 993 inline _Del* 994 get_deleter(const __shared_ptr<_Tp, _Lp>& __p) 995 { return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del))); } 996 997 998 template<typename _Tp, _Lock_policy _Lp> 999 class __weak_ptr 1000 { 1001 public: 1002 typedef _Tp element_type; 1003 1004 __weak_ptr() 1005 : _M_ptr(0), _M_refcount() // never throws 1006 { } 1007 1008 // Generated copy constructor, assignment, destructor are fine. 1009 1010 // The "obvious" converting constructor implementation: 1011 // 1012 // template<typename _Tp1> 1013 // __weak_ptr(const __weak_ptr<_Tp1, _Lp>& __r) 1014 // : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) // never throws 1015 // { } 1016 // 1017 // has a serious problem. 1018 // 1019 // __r._M_ptr may already have been invalidated. The _M_ptr(__r._M_ptr) 1020 // conversion may require access to *__r._M_ptr (virtual inheritance). 1021 // 1022 // It is not possible to avoid spurious access violations since 1023 // in multithreaded programs __r._M_ptr may be invalidated at any point. 1024 template<typename _Tp1> 1025 __weak_ptr(const __weak_ptr<_Tp1, _Lp>& __r) 1026 : _M_refcount(__r._M_refcount) // never throws 1027 { 1028 __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) 1029 _M_ptr = __r.lock().get(); 1030 } 1031 1032 template<typename _Tp1> 1033 __weak_ptr(const __shared_ptr<_Tp1, _Lp>& __r) 1034 : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) // never throws 1035 { __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) } 1036 1037 template<typename _Tp1> 1038 __weak_ptr& 1039 operator=(const __weak_ptr<_Tp1, _Lp>& __r) // never throws 1040 { 1041 _M_ptr = __r.lock().get(); 1042 _M_refcount = __r._M_refcount; 1043 return *this; 1044 } 1045 1046 template<typename _Tp1> 1047 __weak_ptr& 1048 operator=(const __shared_ptr<_Tp1, _Lp>& __r) // never throws 1049 { 1050 _M_ptr = __r._M_ptr; 1051 _M_refcount = __r._M_refcount; 1052 return *this; 1053 } 1054 1055 __shared_ptr<_Tp, _Lp> 1056 lock() const // never throws 1057 { 1058 #ifdef __GTHREADS 1059 // Optimization: avoid throw overhead. 1060 if (expired()) 1061 return __shared_ptr<element_type, _Lp>(); 1062 1063 __try 1064 { 1065 return __shared_ptr<element_type, _Lp>(*this); 1066 } 1067 __catch(const bad_weak_ptr&) 1068 { 1069 // Q: How can we get here? 1070 // A: Another thread may have invalidated r after the 1071 // use_count test above. 1072 return __shared_ptr<element_type, _Lp>(); 1073 } 1074 1075 #else 1076 // Optimization: avoid try/catch overhead when single threaded. 1077 return expired() ? __shared_ptr<element_type, _Lp>() 1078 : __shared_ptr<element_type, _Lp>(*this); 1079 1080 #endif 1081 } // XXX MT 1082 1083 long 1084 use_count() const // never throws 1085 { return _M_refcount._M_get_use_count(); } 1086 1087 bool 1088 expired() const // never throws 1089 { return _M_refcount._M_get_use_count() == 0; } 1090 1091 template<typename _Tp1> 1092 bool 1093 owner_before(const __shared_ptr<_Tp1, _Lp>& __rhs) const 1094 { return _M_refcount._M_less(__rhs._M_refcount); } 1095 1096 template<typename _Tp1> 1097 bool 1098 owner_before(const __weak_ptr<_Tp1, _Lp>& __rhs) const 1099 { return _M_refcount._M_less(__rhs._M_refcount); } 1100 1101 void 1102 reset() // never throws 1103 { __weak_ptr().swap(*this); } 1104 1105 void 1106 swap(__weak_ptr& __s) // never throws 1107 { 1108 std::swap(_M_ptr, __s._M_ptr); 1109 _M_refcount._M_swap(__s._M_refcount); 1110 } 1111 1112 // comparisons 1113 template<typename _Tp1> 1114 bool operator<(const __weak_ptr<_Tp1, _Lp>&) const = delete; 1115 template<typename _Tp1> 1116 bool operator<=(const __weak_ptr<_Tp1, _Lp>&) const = delete; 1117 template<typename _Tp1> 1118 bool operator>(const __weak_ptr<_Tp1, _Lp>&) const = delete; 1119 template<typename _Tp1> 1120 bool operator>=(const __weak_ptr<_Tp1, _Lp>&) const = delete; 1121 1122 private: 1123 // Used by __enable_shared_from_this. 1124 void 1125 _M_assign(_Tp* __ptr, const __shared_count<_Lp>& __refcount) 1126 { 1127 _M_ptr = __ptr; 1128 _M_refcount = __refcount; 1129 } 1130 1131 template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr; 1132 template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr; 1133 friend class __enable_shared_from_this<_Tp, _Lp>; 1134 friend class enable_shared_from_this<_Tp>; 1135 1136 _Tp* _M_ptr; // Contained pointer. 1137 __weak_count<_Lp> _M_refcount; // Reference counter. 1138 }; 1139 1140 // 20.8.13.3.7 weak_ptr specialized algorithms. 1141 template<typename _Tp, _Lock_policy _Lp> 1142 inline void 1143 swap(__weak_ptr<_Tp, _Lp>& __a, __weak_ptr<_Tp, _Lp>& __b) 1144 { __a.swap(__b); } 1145 1146 /// owner_less 1147 template<typename _Tp> struct owner_less; 1148 1149 template<typename _Tp, typename _Tp1> 1150 struct _Sp_owner_less : public binary_function<_Tp, _Tp, bool> 1151 { 1152 bool 1153 operator()(const _Tp& __lhs, const _Tp& __rhs) const 1154 { return __lhs.owner_before(__rhs); } 1155 bool 1156 operator()(const _Tp& __lhs, const _Tp1& __rhs) const 1157 { return __lhs.owner_before(__rhs); } 1158 bool 1159 operator()(const _Tp1& __lhs, const _Tp& __rhs) const 1160 { return __lhs.owner_before(__rhs); } 1161 }; 1162 1163 template<typename _Tp, _Lock_policy _Lp> 1164 struct owner_less<__shared_ptr<_Tp, _Lp>> 1165 : public _Sp_owner_less<__shared_ptr<_Tp, _Lp>, __weak_ptr<_Tp, _Lp>> 1166 { }; 1167 1168 template<typename _Tp, _Lock_policy _Lp> 1169 struct owner_less<__weak_ptr<_Tp, _Lp>> 1170 : public _Sp_owner_less<__weak_ptr<_Tp, _Lp>, __shared_ptr<_Tp, _Lp>> 1171 { 1172 }; 1173 1174 1175 template<typename _Tp, _Lock_policy _Lp> 1176 class __enable_shared_from_this 1177 { 1178 protected: 1179 __enable_shared_from_this() { } 1180 1181 __enable_shared_from_this(const __enable_shared_from_this&) { } 1182 1183 __enable_shared_from_this& 1184 operator=(const __enable_shared_from_this&) 1185 { return *this; } 1186 1187 ~__enable_shared_from_this() { } 1188 1189 public: 1190 __shared_ptr<_Tp, _Lp> 1191 shared_from_this() 1192 { return __shared_ptr<_Tp, _Lp>(this->_M_weak_this); } 1193 1194 __shared_ptr<const _Tp, _Lp> 1195 shared_from_this() const 1196 { return __shared_ptr<const _Tp, _Lp>(this->_M_weak_this); } 1197 1198 private: 1199 template<typename _Tp1> 1200 void 1201 _M_weak_assign(_Tp1* __p, const __shared_count<_Lp>& __n) const 1202 { _M_weak_this._M_assign(__p, __n); } 1203 1204 template<typename _Tp1> 1205 friend void 1206 __enable_shared_from_this_helper(const __shared_count<_Lp>& __pn, 1207 const __enable_shared_from_this* __pe, 1208 const _Tp1* __px) 1209 { 1210 if (__pe != 0) 1211 __pe->_M_weak_assign(const_cast<_Tp1*>(__px), __pn); 1212 } 1213 1214 mutable __weak_ptr<_Tp, _Lp> _M_weak_this; 1215 }; 1216 1217 /** 1218 * @brief A smart pointer with reference-counted copy semantics. 1219 * 1220 * The object pointed to is deleted when the last shared_ptr pointing to 1221 * it is destroyed or reset. 1222 */ 1223 template<typename _Tp> 1224 class shared_ptr 1225 : public __shared_ptr<_Tp> 1226 { 1227 public: 1228 shared_ptr() 1229 : __shared_ptr<_Tp>() { } 1230 1231 template<typename _Tp1> 1232 explicit 1233 shared_ptr(_Tp1* __p) 1234 : __shared_ptr<_Tp>(__p) { } 1235 1236 template<typename _Tp1, typename _Deleter> 1237 shared_ptr(_Tp1* __p, _Deleter __d) 1238 : __shared_ptr<_Tp>(__p, __d) { } 1239 1240 template<typename _Tp1, typename _Deleter, typename _Alloc> 1241 shared_ptr(_Tp1* __p, _Deleter __d, const _Alloc& __a) 1242 : __shared_ptr<_Tp>(__p, __d, __a) { } 1243 1244 // Aliasing constructor 1245 template<typename _Tp1> 1246 shared_ptr(const shared_ptr<_Tp1>& __r, _Tp* __p) 1247 : __shared_ptr<_Tp>(__r, __p) { } 1248 1249 template<typename _Tp1> 1250 shared_ptr(const shared_ptr<_Tp1>& __r) 1251 : __shared_ptr<_Tp>(__r) { } 1252 1253 shared_ptr(shared_ptr&& __r) 1254 : __shared_ptr<_Tp>(std::move(__r)) { } 1255 1256 template<typename _Tp1> 1257 shared_ptr(shared_ptr<_Tp1>&& __r) 1258 : __shared_ptr<_Tp>(std::move(__r)) { } 1259 1260 template<typename _Tp1> 1261 explicit 1262 shared_ptr(const weak_ptr<_Tp1>& __r) 1263 : __shared_ptr<_Tp>(__r) { } 1264 1265 #if _GLIBCXX_DEPRECATED 1266 template<typename _Tp1> 1267 explicit 1268 shared_ptr(std::auto_ptr<_Tp1>&& __r) 1269 : __shared_ptr<_Tp>(std::move(__r)) { } 1270 #endif 1271 1272 template<typename _Tp1, typename _Del> 1273 explicit 1274 shared_ptr(const std::unique_ptr<_Tp1, _Del>&) = delete; 1275 1276 template<typename _Tp1, typename _Del> 1277 explicit 1278 shared_ptr(std::unique_ptr<_Tp1, _Del>&& __r) 1279 : __shared_ptr<_Tp>(std::move(__r)) { } 1280 1281 template<typename _Tp1> 1282 shared_ptr& 1283 operator=(const shared_ptr<_Tp1>& __r) // never throws 1284 { 1285 this->__shared_ptr<_Tp>::operator=(__r); 1286 return *this; 1287 } 1288 1289 #if _GLIBCXX_DEPRECATED 1290 template<typename _Tp1> 1291 shared_ptr& 1292 operator=(std::auto_ptr<_Tp1>&& __r) 1293 { 1294 this->__shared_ptr<_Tp>::operator=(std::move(__r)); 1295 return *this; 1296 } 1297 #endif 1298 1299 shared_ptr& 1300 operator=(shared_ptr&& __r) 1301 { 1302 this->__shared_ptr<_Tp>::operator=(std::move(__r)); 1303 return *this; 1304 } 1305 1306 template<class _Tp1> 1307 shared_ptr& 1308 operator=(shared_ptr<_Tp1>&& __r) 1309 { 1310 this->__shared_ptr<_Tp>::operator=(std::move(__r)); 1311 return *this; 1312 } 1313 1314 template<typename _Tp1, typename _Del> 1315 shared_ptr& 1316 operator=(const std::unique_ptr<_Tp1, _Del>& __r) = delete; 1317 1318 template<typename _Tp1, typename _Del> 1319 shared_ptr& 1320 operator=(std::unique_ptr<_Tp1, _Del>&& __r) 1321 { 1322 this->__shared_ptr<_Tp>::operator=(std::move(__r)); 1323 return *this; 1324 } 1325 1326 private: 1327 // This constructor is non-standard, it is used by allocate_shared. 1328 template<typename _Alloc, typename... _Args> 1329 shared_ptr(_Sp_make_shared_tag __tag, _Alloc __a, _Args&&... __args) 1330 : __shared_ptr<_Tp>(__tag, __a, std::forward<_Args>(__args)...) 1331 { } 1332 1333 template<typename _Tp1, typename _Alloc, typename... _Args> 1334 friend shared_ptr<_Tp1> 1335 allocate_shared(_Alloc __a, _Args&&... __args); 1336 }; 1337 1338 // 20.8.13.2.7 shared_ptr comparisons 1339 template<typename _Tp1, typename _Tp2> 1340 inline bool 1341 operator==(const shared_ptr<_Tp1>& __a, const shared_ptr<_Tp2>& __b) 1342 { return __a.get() == __b.get(); } 1343 1344 template<typename _Tp1, typename _Tp2> 1345 inline bool 1346 operator!=(const shared_ptr<_Tp1>& __a, const shared_ptr<_Tp2>& __b) 1347 { return __a.get() != __b.get(); } 1348 1349 template<typename _Tp1, typename _Tp2> 1350 inline bool 1351 operator<(const shared_ptr<_Tp1>& __a, const shared_ptr<_Tp2>& __b) 1352 { return __a.get() < __b.get(); } 1353 1354 template<typename _Tp> 1355 struct less<shared_ptr<_Tp>> 1356 : public _Sp_less<shared_ptr<_Tp>> 1357 { }; 1358 1359 // 20.8.13.2.9 shared_ptr specialized algorithms. 1360 template<typename _Tp> 1361 inline void 1362 swap(shared_ptr<_Tp>& __a, shared_ptr<_Tp>& __b) 1363 { __a.swap(__b); } 1364 1365 // 20.8.13.2.10 shared_ptr casts. 1366 template<typename _Tp, typename _Tp1> 1367 inline shared_ptr<_Tp> 1368 static_pointer_cast(const shared_ptr<_Tp1>& __r) 1369 { return shared_ptr<_Tp>(__r, static_cast<_Tp*>(__r.get())); } 1370 1371 template<typename _Tp, typename _Tp1> 1372 inline shared_ptr<_Tp> 1373 const_pointer_cast(const shared_ptr<_Tp1>& __r) 1374 { return shared_ptr<_Tp>(__r, const_cast<_Tp*>(__r.get())); } 1375 1376 template<typename _Tp, typename _Tp1> 1377 inline shared_ptr<_Tp> 1378 dynamic_pointer_cast(const shared_ptr<_Tp1>& __r) 1379 { 1380 if (_Tp* __p = dynamic_cast<_Tp*>(__r.get())) 1381 return shared_ptr<_Tp>(__r, __p); 1382 return shared_ptr<_Tp>(); 1383 } 1384 1385 1386 /** 1387 * @brief A smart pointer with weak semantics. 1388 * 1389 * With forwarding constructors and assignment operators. 1390 */ 1391 template<typename _Tp> 1392 class weak_ptr 1393 : public __weak_ptr<_Tp> 1394 { 1395 public: 1396 weak_ptr() 1397 : __weak_ptr<_Tp>() { } 1398 1399 template<typename _Tp1> 1400 weak_ptr(const weak_ptr<_Tp1>& __r) 1401 : __weak_ptr<_Tp>(__r) { } 1402 1403 template<typename _Tp1> 1404 weak_ptr(const shared_ptr<_Tp1>& __r) 1405 : __weak_ptr<_Tp>(__r) { } 1406 1407 template<typename _Tp1> 1408 weak_ptr& 1409 operator=(const weak_ptr<_Tp1>& __r) // never throws 1410 { 1411 this->__weak_ptr<_Tp>::operator=(__r); 1412 return *this; 1413 } 1414 1415 template<typename _Tp1> 1416 weak_ptr& 1417 operator=(const shared_ptr<_Tp1>& __r) // never throws 1418 { 1419 this->__weak_ptr<_Tp>::operator=(__r); 1420 return *this; 1421 } 1422 1423 shared_ptr<_Tp> 1424 lock() const // never throws 1425 { 1426 #ifdef __GTHREADS 1427 if (this->expired()) 1428 return shared_ptr<_Tp>(); 1429 1430 __try 1431 { 1432 return shared_ptr<_Tp>(*this); 1433 } 1434 __catch(const bad_weak_ptr&) 1435 { 1436 return shared_ptr<_Tp>(); 1437 } 1438 #else 1439 return this->expired() ? shared_ptr<_Tp>() 1440 : shared_ptr<_Tp>(*this); 1441 #endif 1442 } 1443 1444 // comparisons 1445 template<typename _Tp1> 1446 bool operator<(const weak_ptr<_Tp1>&) const = delete; 1447 template<typename _Tp1> 1448 bool operator<=(const weak_ptr<_Tp1>&) const = delete; 1449 template<typename _Tp1> 1450 bool operator>(const weak_ptr<_Tp1>&) const = delete; 1451 template<typename _Tp1> 1452 bool operator>=(const weak_ptr<_Tp1>&) const = delete; 1453 }; 1454 1455 // 20.8.13.3.7 weak_ptr specialized algorithms. 1456 template<typename _Tp> 1457 inline void 1458 swap(weak_ptr<_Tp>& __a, weak_ptr<_Tp>& __b) 1459 { __a.swap(__b); } 1460 1461 /// owner_less 1462 template<typename _Tp> 1463 struct owner_less<shared_ptr<_Tp>> 1464 : public _Sp_owner_less<shared_ptr<_Tp>, weak_ptr<_Tp>> 1465 { }; 1466 1467 template<typename _Tp> 1468 struct owner_less<weak_ptr<_Tp>> 1469 : public _Sp_owner_less<weak_ptr<_Tp>, shared_ptr<_Tp>> 1470 { }; 1471 1472 /** 1473 * @brief Base class allowing use of member function shared_from_this. 1474 */ 1475 template<typename _Tp> 1476 class enable_shared_from_this 1477 { 1478 protected: 1479 enable_shared_from_this() { } 1480 1481 enable_shared_from_this(const enable_shared_from_this&) { } 1482 1483 enable_shared_from_this& 1484 operator=(const enable_shared_from_this&) 1485 { return *this; } 1486 1487 ~enable_shared_from_this() { } 1488 1489 public: 1490 shared_ptr<_Tp> 1491 shared_from_this() 1492 { return shared_ptr<_Tp>(this->_M_weak_this); } 1493 1494 shared_ptr<const _Tp> 1495 shared_from_this() const 1496 { return shared_ptr<const _Tp>(this->_M_weak_this); } 1497 1498 private: 1499 template<typename _Tp1> 1500 void 1501 _M_weak_assign(_Tp1* __p, const __shared_count<>& __n) const 1502 { _M_weak_this._M_assign(__p, __n); } 1503 1504 template<typename _Tp1> 1505 friend void 1506 __enable_shared_from_this_helper(const __shared_count<>& __pn, 1507 const enable_shared_from_this* __pe, 1508 const _Tp1* __px) 1509 { 1510 if (__pe != 0) 1511 __pe->_M_weak_assign(const_cast<_Tp1*>(__px), __pn); 1512 } 1513 1514 mutable weak_ptr<_Tp> _M_weak_this; 1515 }; 1516 1517 template<typename _Tp, _Lock_policy _Lp, typename _Alloc, typename... _Args> 1518 inline __shared_ptr<_Tp, _Lp> 1519 __allocate_shared(_Alloc __a, _Args&&... __args) 1520 { 1521 return __shared_ptr<_Tp, _Lp>(_Sp_make_shared_tag(), 1522 std::forward<_Alloc>(__a), std::forward<_Args>(__args)...); 1523 } 1524 1525 template<typename _Tp, _Lock_policy _Lp, typename... _Args> 1526 inline __shared_ptr<_Tp, _Lp> 1527 __make_shared(_Args&&... __args) 1528 { 1529 typedef typename std::remove_const<_Tp>::type _Tp_nc; 1530 return __allocate_shared<_Tp, _Lp>(std::allocator<_Tp_nc>(), 1531 std::forward<_Args>(__args)...); 1532 } 1533 1534 /** @brief Create an object that is owned by a shared_ptr. 1535 * @param __a An allocator. 1536 * @param __args Arguments for the @a _Tp object's constructor. 1537 * @return A shared_ptr that owns the newly created object. 1538 * @throw An exception thrown from @a _Alloc::allocate or from the 1539 * constructor of @a _Tp. 1540 * 1541 * A copy of @a __a will be used to allocate memory for the shared_ptr 1542 * and the new object. 1543 */ 1544 template<typename _Tp, typename _Alloc, typename... _Args> 1545 inline shared_ptr<_Tp> 1546 allocate_shared(_Alloc __a, _Args&&... __args) 1547 { 1548 return shared_ptr<_Tp>(_Sp_make_shared_tag(), std::forward<_Alloc>(__a), 1549 std::forward<_Args>(__args)...); 1550 } 1551 1552 /** @brief Create an object that is owned by a shared_ptr. 1553 * @param __args Arguments for the @a _Tp object's constructor. 1554 * @return A shared_ptr that owns the newly created object. 1555 * @throw std::bad_alloc, or an exception thrown from the 1556 * constructor of @a _Tp. 1557 */ 1558 template<typename _Tp, typename... _Args> 1559 inline shared_ptr<_Tp> 1560 make_shared(_Args&&... __args) 1561 { 1562 typedef typename std::remove_const<_Tp>::type _Tp_nc; 1563 return allocate_shared<_Tp>(std::allocator<_Tp_nc>(), 1564 std::forward<_Args>(__args)...); 1565 } 1566 1567 // @} group pointer_abstractions 1568 1569 _GLIBCXX_END_NAMESPACE 1570 1571 #endif // _SHARED_PTR_H 1572
