libstdc++-v3/include/bits/shared_ptr.h

   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       explicit operator bool() const // never throws
 820       { return _M_ptr == 0 ? false : true; }
 821
 822       bool
 823       unique() const // never throws
 824       { return _M_refcount._M_unique(); }
 825
 826       long
 827       use_count() const // never throws
 828       { return _M_refcount._M_get_use_count(); }
 829
 830       void
 831       swap(__shared_ptr<_Tp, _Lp>&& __other) // never throws
 832       {
 833         std::swap(_M_ptr, __other._M_ptr);
 834         _M_refcount._M_swap(__other._M_refcount);
 835       }
 836
 837       template<typename _Tp1>
 838         bool
 839         owner_before(__shared_ptr<_Tp1, _Lp> const& __rhs) const
 840         { return _M_refcount._M_less(__rhs._M_refcount); }
 841
 842       template<typename _Tp1>
 843         bool
 844         owner_before(__weak_ptr<_Tp1, _Lp> const& __rhs) const
 845         { return _M_refcount._M_less(__rhs._M_refcount); }
 846
 847     protected:
 848       // This constructor is non-standard, it is used by allocate_shared.
 849       template<typename _Alloc, typename... _Args>
 850         __shared_ptr(_Sp_make_shared_tag __tag, _Alloc __a, _Args&&... __args)
 851         : _M_ptr(), _M_refcount(__tag, (_Tp*)0, __a,
 852                                 std::forward<_Args>(__args)...)
 853         {
 854           // _M_ptr needs to point to the newly constructed object.
 855           // This relies on _Sp_counted_ptr_inplace::_M_get_deleter.
 856           void* __p = _M_refcount._M_get_deleter(typeid(__tag));
 857           _M_ptr = static_cast<_Tp*>(__p);
 858           __enable_shared_from_this_helper(_M_refcount, _M_ptr, _M_ptr);
 859         }
 860
 861       template<typename _Tp1, _Lock_policy _Lp1, typename _Alloc,
 862                typename... _Args>
 863         friend __shared_ptr<_Tp1, _Lp1>
 864         __allocate_shared(_Alloc __a, _Args&&... __args);
 865
 866     private:
 867       void*
 868       _M_get_deleter(const std::type_info& __ti) const
 869       { return _M_refcount._M_get_deleter(__ti); }
 870
 871       template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr;
 872       template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;
 873
 874       template<typename _Del, typename _Tp1, _Lock_policy _Lp1>
 875         friend _Del* get_deleter(const __shared_ptr<_Tp1, _Lp1>&);
 876
 877       _Tp*                 _M_ptr;         // Contained pointer.
 878       __shared_count<_Lp>  _M_refcount;    // Reference counter.
 879     };
 880
 881   // 20.8.13.2.7 shared_ptr comparisons
 882   template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
 883     inline bool
 884     operator==(const __shared_ptr<_Tp1, _Lp>& __a,
 885         const __shared_ptr<_Tp2, _Lp>& __b)
 886     { return __a.get() == __b.get(); }
 887
 888   template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
 889     inline bool
 890     operator!=(const __shared_ptr<_Tp1, _Lp>& __a,
 891         const __shared_ptr<_Tp2, _Lp>& __b)
 892     { return __a.get() != __b.get(); }
 893
 894   template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
 895     inline bool
 896     operator<(const __shared_ptr<_Tp1, _Lp>& __a,
 897         const __shared_ptr<_Tp2, _Lp>& __b)
 898     { return __a.get() < __b.get(); }
 899
 900   template<typename _Sp>
 901     struct _Sp_less : public binary_function<_Sp, _Sp, bool>
 902     {
 903       bool
 904       operator()(const _Sp& __lhs, const _Sp& __rhs) const
 905       {
 906         return std::less<typename _Sp::element_type*>()(__lhs.get(),
 907             __rhs.get());
 908       }
 909     };
 910
 911   template<typename _Tp, _Lock_policy _Lp>
 912     struct less<__shared_ptr<_Tp, _Lp>>
 913     : public _Sp_less<__shared_ptr<_Tp, _Lp>>
 914     { };
 915
 916   // XXX LessThanComparable<_Tp> concept should provide >, >= and <=
 917   template<typename _Tp, _Lock_policy _Lp>
 918     inline bool
 919     operator>(const __shared_ptr<_Tp, _Lp>& __a,
 920         const __shared_ptr<_Tp, _Lp>& __b)
 921     { return __a.get() > __b.get(); }
 922
 923   template<typename _Tp, _Lock_policy _Lp>
 924     inline bool
 925     operator>=(const __shared_ptr<_Tp, _Lp>& __a,
 926         const __shared_ptr<_Tp, _Lp>& __b)
 927     { return __a.get() >= __b.get(); }
 928
 929   template<typename _Tp, _Lock_policy _Lp>
 930     inline bool
 931     operator<=(const __shared_ptr<_Tp, _Lp>& __a,
 932         const __shared_ptr<_Tp, _Lp>& __b)
 933     { return __a.get() <= __b.get(); }
 934
 935   // 2.2.3.8 shared_ptr specialized algorithms.
 936   template<typename _Tp, _Lock_policy _Lp>
 937     inline void
 938     swap(__shared_ptr<_Tp, _Lp>& __a, __shared_ptr<_Tp, _Lp>& __b)
 939     { __a.swap(__b); }
 940
 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   template<typename _Tp, _Lock_policy _Lp>
 947     inline void
 948     swap(__shared_ptr<_Tp, _Lp>& __a, __shared_ptr<_Tp, _Lp>&& __b)
 949     { __a.swap(__b); }
 950
 951   // 2.2.3.9 shared_ptr casts
 952   /** @warning The seemingly equivalent
 953    *           <code>shared_ptr<_Tp, _Lp>(static_cast<_Tp*>(__r.get()))</code>
 954    *           will eventually result in undefined behaviour,
 955    *           attempting to delete the same object twice.
 956    */
 957   template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
 958     inline __shared_ptr<_Tp, _Lp>
 959     static_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r)
 960     { return __shared_ptr<_Tp, _Lp>(__r, static_cast<_Tp*>(__r.get())); }
 961
 962   /** @warning The seemingly equivalent
 963    *           <code>shared_ptr<_Tp, _Lp>(const_cast<_Tp*>(__r.get()))</code>
 964    *           will eventually result in undefined behaviour,
 965    *           attempting to delete the same object twice.
 966    */
 967   template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
 968     inline __shared_ptr<_Tp, _Lp>
 969     const_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r)
 970     { return __shared_ptr<_Tp, _Lp>(__r, const_cast<_Tp*>(__r.get())); }
 971
 972   /** @warning The seemingly equivalent
 973    *           <code>shared_ptr<_Tp, _Lp>(dynamic_cast<_Tp*>(__r.get()))</code>
 974    *           will eventually result in undefined behaviour,
 975    *           attempting to delete the same object twice.
 976    */
 977   template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
 978     inline __shared_ptr<_Tp, _Lp>
 979     dynamic_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r)
 980     {
 981       if (_Tp* __p = dynamic_cast<_Tp*>(__r.get()))
 982         return __shared_ptr<_Tp, _Lp>(__r, __p);
 983       return __shared_ptr<_Tp, _Lp>();
 984     }
 985
 986   // 2.2.3.7 shared_ptr I/O
 987   template<typename _Ch, typename _Tr, typename _Tp, _Lock_policy _Lp>
 988     std::basic_ostream<_Ch, _Tr>&
 989     operator<<(std::basic_ostream<_Ch, _Tr>& __os,
 990                const __shared_ptr<_Tp, _Lp>& __p)
 991     {
 992       __os << __p.get();
 993       return __os;
 994     }
 995
 996   // 2.2.3.10 shared_ptr get_deleter (experimental)
 997   template<typename _Del, typename _Tp, _Lock_policy _Lp>
 998     inline _Del*
 999     get_deleter(const __shared_ptr<_Tp, _Lp>& __p)
1000     { return static_cast<_Del*>(__p._M_get_deleter(typeid(_Del))); }
1001
1002
1003   template<typename _Tp, _Lock_policy _Lp>
1004     class __weak_ptr
1005     {
1006     public:
1007       typedef _Tp element_type;
1008
1009       __weak_ptr()
1010       : _M_ptr(0), _M_refcount() // never throws
1011       { }
1012
1013       // Generated copy constructor, assignment, destructor are fine.
1014
1015       // The "obvious" converting constructor implementation:
1016       //
1017       //  template<typename _Tp1>
1018       //    __weak_ptr(const __weak_ptr<_Tp1, _Lp>& __r)
1019       //    : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) // never throws
1020       //    { }
1021       //
1022       // has a serious problem.
1023       //
1024       //  __r._M_ptr may already have been invalidated. The _M_ptr(__r._M_ptr)
1025       //  conversion may require access to *__r._M_ptr (virtual inheritance).
1026       //
1027       // It is not possible to avoid spurious access violations since
1028       // in multithreaded programs __r._M_ptr may be invalidated at any point.
1029       template<typename _Tp1>
1030         __weak_ptr(const __weak_ptr<_Tp1, _Lp>& __r)
1031         : _M_refcount(__r._M_refcount) // never throws
1032         {
1033           __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>)
1034           _M_ptr = __r.lock().get();
1035         }
1036
1037       template<typename _Tp1>
1038         __weak_ptr(const __shared_ptr<_Tp1, _Lp>& __r)
1039         : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) // never throws
1040         { __glibcxx_function_requires(_ConvertibleConcept<_Tp1*, _Tp*>) }
1041
1042       template<typename _Tp1>
1043         __weak_ptr&
1044         operator=(const __weak_ptr<_Tp1, _Lp>& __r) // never throws
1045         {
1046           _M_ptr = __r.lock().get();
1047           _M_refcount = __r._M_refcount;
1048           return *this;
1049         }
1050
1051       template<typename _Tp1>
1052         __weak_ptr&
1053         operator=(const __shared_ptr<_Tp1, _Lp>& __r) // never throws
1054         {
1055           _M_ptr = __r._M_ptr;
1056           _M_refcount = __r._M_refcount;
1057           return *this;
1058         }
1059
1060       __shared_ptr<_Tp, _Lp>
1061       lock() const // never throws
1062       {
1063 #ifdef __GTHREADS
1064         // Optimization: avoid throw overhead.
1065         if (expired())
1066           return __shared_ptr<element_type, _Lp>();
1067
1068         __try
1069           {
1070             return __shared_ptr<element_type, _Lp>(*this);
1071           }
1072         __catch(const bad_weak_ptr&)
1073           {
1074             // Q: How can we get here?
1075             // A: Another thread may have invalidated r after the
1076             //    use_count test above.
1077             return __shared_ptr<element_type, _Lp>();
1078           }
1079
1080 #else
1081         // Optimization: avoid try/catch overhead when single threaded.
1082         return expired() ? __shared_ptr<element_type, _Lp>()
1083                          : __shared_ptr<element_type, _Lp>(*this);
1084
1085 #endif
1086       } // XXX MT
1087
1088       long
1089       use_count() const // never throws
1090       { return _M_refcount._M_get_use_count(); }
1091
1092       bool
1093       expired() const // never throws
1094       { return _M_refcount._M_get_use_count() == 0; }
1095
1096       template<typename _Tp1>
1097         bool
1098         owner_before(const __shared_ptr<_Tp1, _Lp>& __rhs) const
1099         { return _M_refcount._M_less(__rhs._M_refcount); }
1100
1101       template<typename _Tp1>
1102         bool
1103         owner_before(const __weak_ptr<_Tp1, _Lp>& __rhs) const
1104         { return _M_refcount._M_less(__rhs._M_refcount); }
1105
1106       void
1107       reset() // never throws
1108       { __weak_ptr().swap(*this); }
1109
1110       void
1111       swap(__weak_ptr& __s) // never throws
1112       {
1113         std::swap(_M_ptr, __s._M_ptr);
1114         _M_refcount._M_swap(__s._M_refcount);
1115       }
1116
1117       // comparisons
1118       template<typename _Tp1>
1119         bool operator<(const __weak_ptr<_Tp1, _Lp>&) const = delete;
1120       template<typename _Tp1>
1121         bool operator<=(const __weak_ptr<_Tp1, _Lp>&) const = delete;
1122       template<typename _Tp1>
1123         bool operator>(const __weak_ptr<_Tp1, _Lp>&) const = delete;
1124       template<typename _Tp1>
1125         bool operator>=(const __weak_ptr<_Tp1, _Lp>&) const = delete;
1126
1127     private:
1128       // Used by __enable_shared_from_this.
1129       void
1130       _M_assign(_Tp* __ptr, const __shared_count<_Lp>& __refcount)
1131       {
1132         _M_ptr = __ptr;
1133         _M_refcount = __refcount;
1134       }
1135
1136       template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr;
1137       template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;
1138       friend class __enable_shared_from_this<_Tp, _Lp>;
1139       friend class enable_shared_from_this<_Tp>;
1140
1141       _Tp*               _M_ptr;         // Contained pointer.
1142       __weak_count<_Lp>  _M_refcount;    // Reference counter.
1143     };
1144
1145   // 20.8.13.3.7 weak_ptr specialized algorithms.
1146   template<typename _Tp, _Lock_policy _Lp>
1147     inline void
1148     swap(__weak_ptr<_Tp, _Lp>& __a, __weak_ptr<_Tp, _Lp>& __b)
1149     { __a.swap(__b); }
1150
1151   /// owner_less
1152   template<typename _Tp> struct owner_less;
1153
1154   template<typename _Tp, typename _Tp1>
1155     struct _Sp_owner_less : public binary_function<_Tp, _Tp, bool>
1156     {
1157       bool
1158       operator()(const _Tp& __lhs, const _Tp& __rhs) const
1159       { return __lhs.owner_before(__rhs); }
1160       bool
1161       operator()(const _Tp& __lhs, const _Tp1& __rhs) const
1162       { return __lhs.owner_before(__rhs); }
1163       bool
1164       operator()(const _Tp1& __lhs, const _Tp& __rhs) const
1165       { return __lhs.owner_before(__rhs); }
1166     };
1167
1168   template<typename _Tp, _Lock_policy _Lp>
1169     struct owner_less<__shared_ptr<_Tp, _Lp>>
1170     : public _Sp_owner_less<__shared_ptr<_Tp, _Lp>, __weak_ptr<_Tp, _Lp>>
1171     { };
1172
1173   template<typename _Tp, _Lock_policy _Lp>
1174     struct owner_less<__weak_ptr<_Tp, _Lp>>
1175     : public _Sp_owner_less<__weak_ptr<_Tp, _Lp>, __shared_ptr<_Tp, _Lp>>
1176     {
1177     };
1178
1179
1180   template<typename _Tp, _Lock_policy _Lp>
1181     class __enable_shared_from_this
1182     {
1183     protected:
1184       __enable_shared_from_this() { }
1185
1186       __enable_shared_from_this(const __enable_shared_from_this&) { }
1187
1188       __enable_shared_from_this&
1189       operator=(const __enable_shared_from_this&)
1190       { return *this; }
1191
1192       ~__enable_shared_from_this() { }
1193
1194     public:
1195       __shared_ptr<_Tp, _Lp>
1196       shared_from_this()
1197       { return __shared_ptr<_Tp, _Lp>(this->_M_weak_this); }
1198
1199       __shared_ptr<const _Tp, _Lp>
1200       shared_from_this() const
1201       { return __shared_ptr<const _Tp, _Lp>(this->_M_weak_this); }
1202
1203     private:
1204       template<typename _Tp1>
1205         void
1206         _M_weak_assign(_Tp1* __p, const __shared_count<_Lp>& __n) const
1207         { _M_weak_this._M_assign(__p, __n); }
1208
1209       template<typename _Tp1>
1210         friend void
1211         __enable_shared_from_this_helper(const __shared_count<_Lp>& __pn,
1212                                          const __enable_shared_from_this* __pe,
1213                                          const _Tp1* __px)
1214         {
1215           if (__pe != 0)
1216             __pe->_M_weak_assign(const_cast<_Tp1*>(__px), __pn);
1217         }
1218
1219       mutable __weak_ptr<_Tp, _Lp>  _M_weak_this;
1220     };
1221
1222   /**
1223    *  @brief A smart pointer with reference-counted copy semantics.
1224    *
1225    *  The object pointed to is deleted when the last shared_ptr pointing to
1226    *  it is destroyed or reset.
1227    */
1228   template<typename _Tp>
1229     class shared_ptr
1230     : public __shared_ptr<_Tp>
1231     {
1232     public:
1233       shared_ptr()
1234       : __shared_ptr<_Tp>() { }
1235
1236       template<typename _Tp1>
1237         explicit
1238         shared_ptr(_Tp1* __p)
1239         : __shared_ptr<_Tp>(__p) { }
1240
1241       template<typename _Tp1, typename _Deleter>
1242         shared_ptr(_Tp1* __p, _Deleter __d)
1243         : __shared_ptr<_Tp>(__p, __d) { }
1244
1245       template<typename _Tp1, typename _Deleter, typename _Alloc>
1246         shared_ptr(_Tp1* __p, _Deleter __d, const _Alloc& __a)
1247         : __shared_ptr<_Tp>(__p, __d, __a) { }
1248
1249       // Aliasing constructor
1250       template<typename _Tp1>
1251         shared_ptr(const shared_ptr<_Tp1>& __r, _Tp* __p)
1252         : __shared_ptr<_Tp>(__r, __p) { }
1253
1254       template<typename _Tp1>
1255         shared_ptr(const shared_ptr<_Tp1>& __r)
1256         : __shared_ptr<_Tp>(__r) { }
1257
1258       shared_ptr(shared_ptr&& __r)
1259       : __shared_ptr<_Tp>(std::move(__r)) { }
1260
1261       template<typename _Tp1>
1262         shared_ptr(shared_ptr<_Tp1>&& __r)
1263         : __shared_ptr<_Tp>(std::move(__r)) { }
1264
1265       template<typename _Tp1>
1266         explicit
1267         shared_ptr(const weak_ptr<_Tp1>& __r)
1268         : __shared_ptr<_Tp>(__r) { }
1269
1270 #if _GLIBCXX_DEPRECATED
1271       template<typename _Tp1>
1272         explicit
1273         shared_ptr(std::auto_ptr<_Tp1>&& __r)
1274         : __shared_ptr<_Tp>(std::move(__r)) { }
1275 #endif
1276
1277       template<typename _Tp1, typename _Del>
1278         explicit
1279         shared_ptr(const std::unique_ptr<_Tp1, _Del>&) = delete;
1280
1281       template<typename _Tp1, typename _Del>
1282         explicit
1283         shared_ptr(std::unique_ptr<_Tp1, _Del>&& __r)
1284         : __shared_ptr<_Tp>(std::move(__r)) { }
1285
1286       template<typename _Tp1>
1287         shared_ptr&
1288         operator=(const shared_ptr<_Tp1>& __r) // never throws
1289         {
1290           this->__shared_ptr<_Tp>::operator=(__r);
1291           return *this;
1292         }
1293
1294 #if _GLIBCXX_DEPRECATED
1295       template<typename _Tp1>
1296         shared_ptr&
1297         operator=(std::auto_ptr<_Tp1>&& __r)
1298         {
1299           this->__shared_ptr<_Tp>::operator=(std::move(__r));
1300           return *this;
1301         }
1302 #endif
1303
1304       shared_ptr&
1305       operator=(shared_ptr&& __r)
1306       {
1307         this->__shared_ptr<_Tp>::operator=(std::move(__r));
1308         return *this;
1309       }
1310
1311       template<class _Tp1>
1312         shared_ptr&
1313         operator=(shared_ptr<_Tp1>&& __r)
1314         {
1315           this->__shared_ptr<_Tp>::operator=(std::move(__r));
1316           return *this;
1317         }
1318
1319       template<typename _Tp1, typename _Del>
1320         shared_ptr&
1321         operator=(const std::unique_ptr<_Tp1, _Del>& __r) = delete;
1322
1323       template<typename _Tp1, typename _Del>
1324         shared_ptr&
1325         operator=(std::unique_ptr<_Tp1, _Del>&& __r)
1326         {
1327           this->__shared_ptr<_Tp>::operator=(std::move(__r));
1328           return *this;
1329         }
1330
1331     private:
1332       // This constructor is non-standard, it is used by allocate_shared.
1333       template<typename _Alloc, typename... _Args>
1334         shared_ptr(_Sp_make_shared_tag __tag, _Alloc __a, _Args&&... __args)
1335         : __shared_ptr<_Tp>(__tag, __a, std::forward<_Args>(__args)...)
1336         { }
1337
1338       template<typename _Tp1, typename _Alloc, typename... _Args>
1339         friend shared_ptr<_Tp1>
1340         allocate_shared(_Alloc __a, _Args&&... __args);
1341     };
1342
1343   // 20.8.13.2.7 shared_ptr comparisons
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 _Tp1, typename _Tp2>
1355     inline bool
1356     operator<(const shared_ptr<_Tp1>& __a, const shared_ptr<_Tp2>& __b)
1357     { return __a.get() < __b.get(); }
1358
1359   template<typename _Tp>
1360     struct less<shared_ptr<_Tp>>
1361     : public _Sp_less<shared_ptr<_Tp>>
1362     { };
1363
1364   // 20.8.13.2.9 shared_ptr specialized algorithms.
1365   template<typename _Tp>
1366     inline void
1367     swap(shared_ptr<_Tp>& __a, shared_ptr<_Tp>& __b)
1368     { __a.swap(__b); }
1369
1370   template<typename _Tp>
1371     inline void
1372     swap(shared_ptr<_Tp>&& __a, shared_ptr<_Tp>& __b)
1373     { __a.swap(__b); }
1374
1375   template<typename _Tp>
1376     inline void
1377     swap(shared_ptr<_Tp>& __a, shared_ptr<_Tp>&& __b)
1378     { __a.swap(__b); }
1379
1380   // 20.8.13.2.10 shared_ptr casts.
1381   template<typename _Tp, typename _Tp1>
1382     inline shared_ptr<_Tp>
1383     static_pointer_cast(const shared_ptr<_Tp1>& __r)
1384     { return shared_ptr<_Tp>(__r, static_cast<_Tp*>(__r.get())); }
1385
1386   template<typename _Tp, typename _Tp1>
1387     inline shared_ptr<_Tp>
1388     const_pointer_cast(const shared_ptr<_Tp1>& __r)
1389     { return shared_ptr<_Tp>(__r, const_cast<_Tp*>(__r.get())); }
1390
1391   template<typename _Tp, typename _Tp1>
1392     inline shared_ptr<_Tp>
1393     dynamic_pointer_cast(const shared_ptr<_Tp1>& __r)
1394     {
1395       if (_Tp* __p = dynamic_cast<_Tp*>(__r.get()))
1396         return shared_ptr<_Tp>(__r, __p);
1397       return shared_ptr<_Tp>();
1398     }
1399
1400
1401   /**
1402    *  @brief A smart pointer with weak semantics.
1403    *
1404    *  With forwarding constructors and assignment operators.
1405    */
1406   template<typename _Tp>
1407     class weak_ptr
1408     : public __weak_ptr<_Tp>
1409     {
1410     public:
1411       weak_ptr()
1412       : __weak_ptr<_Tp>() { }
1413
1414       template<typename _Tp1>
1415         weak_ptr(const weak_ptr<_Tp1>& __r)
1416         : __weak_ptr<_Tp>(__r) { }
1417
1418       template<typename _Tp1>
1419         weak_ptr(const shared_ptr<_Tp1>& __r)
1420         : __weak_ptr<_Tp>(__r) { }
1421
1422       template<typename _Tp1>
1423         weak_ptr&
1424         operator=(const weak_ptr<_Tp1>& __r) // never throws
1425         {
1426           this->__weak_ptr<_Tp>::operator=(__r);
1427           return *this;
1428         }
1429
1430       template<typename _Tp1>
1431         weak_ptr&
1432         operator=(const shared_ptr<_Tp1>& __r) // never throws
1433         {
1434           this->__weak_ptr<_Tp>::operator=(__r);
1435           return *this;
1436         }
1437
1438       shared_ptr<_Tp>
1439       lock() const // never throws
1440       {
1441 #ifdef __GTHREADS
1442         if (this->expired())
1443           return shared_ptr<_Tp>();
1444
1445         __try
1446           {
1447             return shared_ptr<_Tp>(*this);
1448           }
1449         __catch(const bad_weak_ptr&)
1450           {
1451             return shared_ptr<_Tp>();
1452           }
1453 #else
1454         return this->expired() ? shared_ptr<_Tp>()
1455                                : shared_ptr<_Tp>(*this);
1456 #endif
1457       }
1458
1459       // comparisons
1460       template<typename _Tp1>
1461         bool operator<(const weak_ptr<_Tp1>&) const = delete;
1462       template<typename _Tp1>
1463         bool operator<=(const weak_ptr<_Tp1>&) const = delete;
1464       template<typename _Tp1>
1465         bool operator>(const weak_ptr<_Tp1>&) const = delete;
1466       template<typename _Tp1>
1467         bool operator>=(const weak_ptr<_Tp1>&) const = delete;
1468     };
1469
1470   // 20.8.13.3.7 weak_ptr specialized algorithms.
1471   template<typename _Tp>
1472     inline void
1473     swap(weak_ptr<_Tp>& __a, weak_ptr<_Tp>& __b)
1474     { __a.swap(__b); }
1475
1476   /// owner_less
1477   template<typename _Tp>
1478     struct owner_less<shared_ptr<_Tp>>
1479     : public _Sp_owner_less<shared_ptr<_Tp>, weak_ptr<_Tp>>
1480     { };
1481
1482   template<typename _Tp>
1483     struct owner_less<weak_ptr<_Tp>>
1484     : public _Sp_owner_less<weak_ptr<_Tp>, shared_ptr<_Tp>>
1485     { };
1486
1487   /**
1488    *  @brief Base class allowing use of member function shared_from_this.
1489    */
1490   template<typename _Tp>
1491     class enable_shared_from_this
1492     {
1493     protected:
1494       enable_shared_from_this() { }
1495
1496       enable_shared_from_this(const enable_shared_from_this&) { }
1497
1498       enable_shared_from_this&
1499       operator=(const enable_shared_from_this&)
1500       { return *this; }
1501
1502       ~enable_shared_from_this() { }
1503
1504     public:
1505       shared_ptr<_Tp>
1506       shared_from_this()
1507       { return shared_ptr<_Tp>(this->_M_weak_this); }
1508
1509       shared_ptr<const _Tp>
1510       shared_from_this() const
1511       { return shared_ptr<const _Tp>(this->_M_weak_this); }
1512
1513     private:
1514       template<typename _Tp1>
1515         void
1516         _M_weak_assign(_Tp1* __p, const __shared_count<>& __n) const
1517         { _M_weak_this._M_assign(__p, __n); }
1518
1519       template<typename _Tp1>
1520         friend void
1521         __enable_shared_from_this_helper(const __shared_count<>& __pn,
1522                                          const enable_shared_from_this* __pe,
1523                                          const _Tp1* __px)
1524         {
1525           if (__pe != 0)
1526             __pe->_M_weak_assign(const_cast<_Tp1*>(__px), __pn);
1527         }
1528
1529       mutable weak_ptr<_Tp>  _M_weak_this;
1530     };
1531
1532   template<typename _Tp, _Lock_policy _Lp, typename _Alloc, typename... _Args>
1533     inline __shared_ptr<_Tp, _Lp>
1534     __allocate_shared(_Alloc __a, _Args&&... __args)
1535     {
1536       return __shared_ptr<_Tp, _Lp>(_Sp_make_shared_tag(),
1537           std::forward<_Alloc>(__a), std::forward<_Args>(__args)...);
1538     }
1539
1540   template<typename _Tp, _Lock_policy _Lp, typename... _Args>
1541     inline __shared_ptr<_Tp, _Lp>
1542     __make_shared(_Args&&... __args)
1543     {
1544       typedef typename std::remove_const<_Tp>::type _Tp_nc;
1545       return __allocate_shared<_Tp, _Lp>(std::allocator<_Tp_nc>(),
1546               std::forward<_Args>(__args)...);
1547     }
1548
1549   /** @brief  Create an object that is owned by a shared_ptr.
1550    *  @param  __a     An allocator.
1551    *  @param  __args  Arguments for the @a _Tp object's constructor.
1552    *  @return A shared_ptr that owns the newly created object.
1553    *  @throw  An exception thrown from @a _Alloc::allocate or from the
1554    *          constructor of @a _Tp.
1555    *
1556    *  A copy of @a __a will be used to allocate memory for the shared_ptr
1557    *  and the new object.
1558    */
1559   template<typename _Tp, typename _Alloc, typename... _Args>
1560     inline shared_ptr<_Tp>
1561     allocate_shared(_Alloc __a, _Args&&... __args)
1562     {
1563       return shared_ptr<_Tp>(_Sp_make_shared_tag(), std::forward<_Alloc>(__a),
1564               std::forward<_Args>(__args)...);
1565     }
1566
1567   /** @brief  Create an object that is owned by a shared_ptr.
1568    *  @param  __args  Arguments for the @a _Tp object's constructor.
1569    *  @return A shared_ptr that owns the newly created object.
1570    *  @throw  std::bad_alloc, or an exception thrown from the
1571    *          constructor of @a _Tp.
1572    */
1573   template<typename _Tp, typename... _Args>
1574     inline shared_ptr<_Tp>
1575     make_shared(_Args&&... __args)
1576     {
1577       typedef typename std::remove_const<_Tp>::type _Tp_nc;
1578       return allocate_shared<_Tp>(std::allocator<_Tp_nc>(),
1579               std::forward<_Args>(__args)...);
1580     }
1581
1582   // @} group pointer_abstractions
1583
1584 _GLIBCXX_END_NAMESPACE
1585
1586 #endif // _SHARED_PTR_H