1 // <tr1/shared_ptr.h> -*- C++ -*-
3 // Copyright (C) 2007-2024 Free Software Foundation, Inc.
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)
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.
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.
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/>.
26 // Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
29 // Copyright (C) 1998, 1999 Greg Colvin and Beman Dawes.
30 // Copyright (C) 2001, 2002, 2003 Peter Dimov
33 // Copyright (C) 2001, 2002, 2003 Peter Dimov
35 // enable_shared_from_this.hpp
36 // Copyright (C) 2002 Peter Dimov
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)
42 // GCC Note: based on version 1.32.0 of the Boost library.
44 /** @file tr1/shared_ptr.h
45 * This is an internal header file, included by other library headers.
46 * Do not attempt to use it directly. @headername{tr1/memory}
49 #ifndef _TR1_SHARED_PTR_H
50 #define _TR1_SHARED_PTR_H 1
52 namespace std
_GLIBCXX_VISIBILITY(default)
54 _GLIBCXX_BEGIN_NAMESPACE_VERSION
59 * @brief Exception possibly thrown by @c shared_ptr.
62 class bad_weak_ptr
: public std::exception
67 { return "tr1::bad_weak_ptr"; }
70 // Substitute for bad_weak_ptr object in the case of -fno-exceptions.
72 __throw_bad_weak_ptr()
73 { _GLIBCXX_THROW_OR_ABORT(bad_weak_ptr()); }
75 using __gnu_cxx::_Lock_policy
;
76 using __gnu_cxx::__default_lock_policy
;
77 using __gnu_cxx::_S_single
;
78 using __gnu_cxx::_S_mutex
;
79 using __gnu_cxx::_S_atomic
;
81 // Empty helper class except when the template argument is _S_mutex.
82 template<_Lock_policy _Lp
>
86 // The atomic policy uses fully-fenced builtins, single doesn't care.
87 enum { _S_need_barriers
= 0 };
91 class _Mutex_base
<_S_mutex
>
92 : public __gnu_cxx::__mutex
95 // This policy is used when atomic builtins are not available.
96 // The replacement atomic operations might not have the necessary
98 enum { _S_need_barriers
= 1 };
101 template<_Lock_policy _Lp
= __default_lock_policy
>
102 class _Sp_counted_base
103 : public _Mutex_base
<_Lp
>
107 : _M_use_count(1), _M_weak_count(1) { }
110 ~_Sp_counted_base() // nothrow
113 // Called when _M_use_count drops to zero, to release the resources
116 _M_dispose() = 0; // nothrow
118 // Called when _M_weak_count drops to zero.
120 _M_destroy() // nothrow
124 _M_get_deleter(const std::type_info
&) = 0;
128 { __gnu_cxx::__atomic_add_dispatch(&_M_use_count
, 1); }
134 _M_release() // nothrow
136 // Be race-detector-friendly. For more info see bits/c++config.
137 _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_use_count
);
138 if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count
, -1) == 1)
140 _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_use_count
);
142 // There must be a memory barrier between dispose() and destroy()
143 // to ensure that the effects of dispose() are observed in the
144 // thread that runs destroy().
145 // See http://gcc.gnu.org/ml/libstdc++/2005-11/msg00136.html
146 if (_Mutex_base
<_Lp
>::_S_need_barriers
)
148 __atomic_thread_fence (__ATOMIC_ACQ_REL
);
151 // Be race-detector-friendly. For more info see bits/c++config.
152 _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_weak_count
);
153 if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count
,
156 _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_weak_count
);
163 _M_weak_add_ref() // nothrow
164 { __gnu_cxx::__atomic_add_dispatch(&_M_weak_count
, 1); }
167 _M_weak_release() // nothrow
169 // Be race-detector-friendly. For more info see bits/c++config.
170 _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_weak_count
);
171 if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count
, -1) == 1)
173 _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_weak_count
);
174 if (_Mutex_base
<_Lp
>::_S_need_barriers
)
177 // destroy() must observe results of dispose()
178 __atomic_thread_fence (__ATOMIC_ACQ_REL
);
185 _M_get_use_count() const // nothrow
187 // No memory barrier is used here so there is no synchronization
188 // with other threads.
189 return const_cast<const volatile _Atomic_word
&>(_M_use_count
);
193 _Sp_counted_base(_Sp_counted_base
const&);
194 _Sp_counted_base
& operator=(_Sp_counted_base
const&);
196 _Atomic_word _M_use_count
; // #shared
197 _Atomic_word _M_weak_count
; // #weak + (#shared != 0)
202 _Sp_counted_base
<_S_single
>::
205 if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count
, 1) == 0)
208 __throw_bad_weak_ptr();
214 _Sp_counted_base
<_S_mutex
>::
217 __gnu_cxx::__scoped_lock
sentry(*this);
218 if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count
, 1) == 0)
221 __throw_bad_weak_ptr();
227 _Sp_counted_base
<_S_atomic
>::
230 // Perform lock-free add-if-not-zero operation.
231 _Atomic_word __count
= _M_use_count
;
235 __throw_bad_weak_ptr();
236 // Replace the current counter value with the old value + 1, as
237 // long as it's not changed meanwhile.
239 while (!__atomic_compare_exchange_n(&_M_use_count
, &__count
, __count
+ 1,
240 true, __ATOMIC_ACQ_REL
,
244 template<typename _Ptr
, typename _Deleter
, _Lock_policy _Lp
>
245 class _Sp_counted_base_impl
246 : public _Sp_counted_base
<_Lp
>
249 // Precondition: __d(__p) must not throw.
250 _Sp_counted_base_impl(_Ptr __p
, _Deleter __d
)
251 : _M_ptr(__p
), _M_del(__d
) { }
254 _M_dispose() // nothrow
258 _M_get_deleter(const std::type_info
& __ti
)
261 return __ti
== typeid(_Deleter
) ? &_M_del
: 0;
268 _Sp_counted_base_impl(const _Sp_counted_base_impl
&);
269 _Sp_counted_base_impl
& operator=(const _Sp_counted_base_impl
&);
271 _Ptr _M_ptr
; // copy constructor must not throw
272 _Deleter _M_del
; // copy constructor must not throw
275 template<_Lock_policy _Lp
= __default_lock_policy
>
278 template<typename _Tp
>
281 typedef void result_type
;
282 typedef _Tp
* argument_type
;
283 void operator()(_Tp
* __p
) const { delete __p
; }
286 template<_Lock_policy _Lp
= __default_lock_policy
>
291 : _M_pi(0) // nothrow
294 template<typename _Ptr
>
295 __shared_count(_Ptr __p
) : _M_pi(0)
299 typedef typename
std::tr1::remove_pointer
<_Ptr
>::type _Tp
;
300 _M_pi
= new _Sp_counted_base_impl
<_Ptr
, _Sp_deleter
<_Tp
>, _Lp
>(
301 __p
, _Sp_deleter
<_Tp
>());
306 __throw_exception_again
;
310 template<typename _Ptr
, typename _Deleter
>
311 __shared_count(_Ptr __p
, _Deleter __d
) : _M_pi(0)
315 _M_pi
= new _Sp_counted_base_impl
<_Ptr
, _Deleter
, _Lp
>(__p
, __d
);
319 __d(__p
); // Call _Deleter on __p.
320 __throw_exception_again
;
324 #if (__cplusplus < 201103L) || _GLIBCXX_USE_DEPRECATED
325 #pragma GCC diagnostic push
326 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
327 // Special case for auto_ptr<_Tp> to provide the strong guarantee.
328 template<typename _Tp
>
330 __shared_count(std::auto_ptr
<_Tp
>& __r
)
331 : _M_pi(new _Sp_counted_base_impl
<_Tp
*,
332 _Sp_deleter
<_Tp
>, _Lp
>(__r
.get(), _Sp_deleter
<_Tp
>()))
334 #pragma GCC diagnostic pop
337 // Throw bad_weak_ptr when __r._M_get_use_count() == 0.
339 __shared_count(const __weak_count
<_Lp
>& __r
);
341 ~__shared_count() // nothrow
347 __shared_count(const __shared_count
& __r
)
348 : _M_pi(__r
._M_pi
) // nothrow
351 _M_pi
->_M_add_ref_copy();
355 operator=(const __shared_count
& __r
) // nothrow
357 _Sp_counted_base
<_Lp
>* __tmp
= __r
._M_pi
;
361 __tmp
->_M_add_ref_copy();
370 _M_swap(__shared_count
& __r
) // nothrow
372 _Sp_counted_base
<_Lp
>* __tmp
= __r
._M_pi
;
378 _M_get_use_count() const // nothrow
379 { return _M_pi
!= 0 ? _M_pi
->_M_get_use_count() : 0; }
382 _M_unique() const // nothrow
383 { return this->_M_get_use_count() == 1; }
386 operator==(const __shared_count
& __a
, const __shared_count
& __b
)
387 { return __a
._M_pi
== __b
._M_pi
; }
390 operator<(const __shared_count
& __a
, const __shared_count
& __b
)
391 { return std::less
<_Sp_counted_base
<_Lp
>*>()(__a
._M_pi
, __b
._M_pi
); }
394 _M_get_deleter(const std::type_info
& __ti
) const
395 { return _M_pi
? _M_pi
->_M_get_deleter(__ti
) : 0; }
398 friend class __weak_count
<_Lp
>;
400 _Sp_counted_base
<_Lp
>* _M_pi
;
404 template<_Lock_policy _Lp
>
409 : _M_pi(0) // nothrow
412 __weak_count(const __shared_count
<_Lp
>& __r
)
413 : _M_pi(__r
._M_pi
) // nothrow
416 _M_pi
->_M_weak_add_ref();
419 __weak_count(const __weak_count
<_Lp
>& __r
)
420 : _M_pi(__r
._M_pi
) // nothrow
423 _M_pi
->_M_weak_add_ref();
426 ~__weak_count() // nothrow
429 _M_pi
->_M_weak_release();
433 operator=(const __shared_count
<_Lp
>& __r
) // nothrow
435 _Sp_counted_base
<_Lp
>* __tmp
= __r
._M_pi
;
437 __tmp
->_M_weak_add_ref();
439 _M_pi
->_M_weak_release();
445 operator=(const __weak_count
<_Lp
>& __r
) // nothrow
447 _Sp_counted_base
<_Lp
>* __tmp
= __r
._M_pi
;
449 __tmp
->_M_weak_add_ref();
451 _M_pi
->_M_weak_release();
457 _M_swap(__weak_count
<_Lp
>& __r
) // nothrow
459 _Sp_counted_base
<_Lp
>* __tmp
= __r
._M_pi
;
465 _M_get_use_count() const // nothrow
466 { return _M_pi
!= 0 ? _M_pi
->_M_get_use_count() : 0; }
469 operator==(const __weak_count
<_Lp
>& __a
, const __weak_count
<_Lp
>& __b
)
470 { return __a
._M_pi
== __b
._M_pi
; }
473 operator<(const __weak_count
<_Lp
>& __a
, const __weak_count
<_Lp
>& __b
)
474 { return std::less
<_Sp_counted_base
<_Lp
>*>()(__a
._M_pi
, __b
._M_pi
); }
477 friend class __shared_count
<_Lp
>;
479 _Sp_counted_base
<_Lp
>* _M_pi
;
482 // now that __weak_count is defined we can define this constructor:
483 template<_Lock_policy _Lp
>
485 __shared_count
<_Lp
>::
486 __shared_count(const __weak_count
<_Lp
>& __r
)
490 _M_pi
->_M_add_ref_lock();
492 __throw_bad_weak_ptr();
495 // Forward declarations.
496 template<typename _Tp
, _Lock_policy _Lp
= __default_lock_policy
>
499 template<typename _Tp
, _Lock_policy _Lp
= __default_lock_policy
>
502 template<typename _Tp
, _Lock_policy _Lp
= __default_lock_policy
>
503 class __enable_shared_from_this
;
505 template<typename _Tp
>
508 template<typename _Tp
>
511 template<typename _Tp
>
512 class enable_shared_from_this
;
514 // Support for enable_shared_from_this.
516 // Friend of __enable_shared_from_this.
517 template<_Lock_policy _Lp
, typename _Tp1
, typename _Tp2
>
519 __enable_shared_from_this_helper(const __shared_count
<_Lp
>&,
520 const __enable_shared_from_this
<_Tp1
,
523 // Friend of enable_shared_from_this.
524 template<typename _Tp1
, typename _Tp2
>
526 __enable_shared_from_this_helper(const __shared_count
<>&,
527 const enable_shared_from_this
<_Tp1
>*,
530 template<_Lock_policy _Lp
>
532 __enable_shared_from_this_helper(const __shared_count
<_Lp
>&, ...)
536 struct __static_cast_tag
{ };
537 struct __const_cast_tag
{ };
538 struct __dynamic_cast_tag
{ };
540 // A smart pointer with reference-counted copy semantics. The
541 // object pointed to is deleted when the last shared_ptr pointing to
542 // it is destroyed or reset.
543 template<typename _Tp
, _Lock_policy _Lp
>
547 typedef _Tp element_type
;
550 : _M_ptr(0), _M_refcount() // never throws
553 template<typename _Tp1
>
555 __shared_ptr(_Tp1
* __p
)
556 : _M_ptr(__p
), _M_refcount(__p
)
558 __glibcxx_function_requires(_ConvertibleConcept
<_Tp1
*, _Tp
*>)
559 typedef int _IsComplete
[sizeof(_Tp1
)];
560 __enable_shared_from_this_helper(_M_refcount
, __p
, __p
);
563 template<typename _Tp1
, typename _Deleter
>
564 __shared_ptr(_Tp1
* __p
, _Deleter __d
)
565 : _M_ptr(__p
), _M_refcount(__p
, __d
)
567 __glibcxx_function_requires(_ConvertibleConcept
<_Tp1
*, _Tp
*>)
568 // TODO requires _Deleter CopyConstructible and __d(__p) well-formed
569 __enable_shared_from_this_helper(_M_refcount
, __p
, __p
);
572 // generated copy constructor, assignment, destructor are fine.
574 template<typename _Tp1
>
575 __shared_ptr(const __shared_ptr
<_Tp1
, _Lp
>& __r
)
576 : _M_ptr(__r
._M_ptr
), _M_refcount(__r
._M_refcount
) // never throws
577 { __glibcxx_function_requires(_ConvertibleConcept
<_Tp1
*, _Tp
*>) }
579 template<typename _Tp1
>
581 __shared_ptr(const __weak_ptr
<_Tp1
, _Lp
>& __r
)
582 : _M_refcount(__r
._M_refcount
) // may throw
584 __glibcxx_function_requires(_ConvertibleConcept
<_Tp1
*, _Tp
*>)
585 // It is now safe to copy __r._M_ptr, as _M_refcount(__r._M_refcount)
590 #if (__cplusplus < 201103L) || _GLIBCXX_USE_DEPRECATED
591 #pragma GCC diagnostic push
592 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
593 // Postcondition: use_count() == 1 and __r.get() == 0
594 template<typename _Tp1
>
596 __shared_ptr(std::auto_ptr
<_Tp1
>& __r
)
597 : _M_ptr(__r
.get()), _M_refcount()
598 { // TODO requries delete __r.release() well-formed
599 __glibcxx_function_requires(_ConvertibleConcept
<_Tp1
*, _Tp
*>)
600 typedef int _IsComplete
[sizeof(_Tp1
)];
601 _Tp1
* __tmp
= __r
.get();
602 _M_refcount
= __shared_count
<_Lp
>(__r
);
603 __enable_shared_from_this_helper(_M_refcount
, __tmp
, __tmp
);
605 #pragma GCC diagnostic pop
608 template<typename _Tp1
>
609 __shared_ptr(const __shared_ptr
<_Tp1
, _Lp
>& __r
, __static_cast_tag
)
610 : _M_ptr(static_cast<element_type
*>(__r
._M_ptr
)),
611 _M_refcount(__r
._M_refcount
)
614 template<typename _Tp1
>
615 __shared_ptr(const __shared_ptr
<_Tp1
, _Lp
>& __r
, __const_cast_tag
)
616 : _M_ptr(const_cast<element_type
*>(__r
._M_ptr
)),
617 _M_refcount(__r
._M_refcount
)
620 template<typename _Tp1
>
621 __shared_ptr(const __shared_ptr
<_Tp1
, _Lp
>& __r
, __dynamic_cast_tag
)
622 : _M_ptr(dynamic_cast<element_type
*>(__r
._M_ptr
)),
623 _M_refcount(__r
._M_refcount
)
625 if (_M_ptr
== 0) // need to allocate new counter -- the cast failed
626 _M_refcount
= __shared_count
<_Lp
>();
629 template<typename _Tp1
>
631 operator=(const __shared_ptr
<_Tp1
, _Lp
>& __r
) // never throws
634 _M_refcount
= __r
._M_refcount
; // __shared_count::op= doesn't throw
638 #if (__cplusplus < 201103L) || _GLIBCXX_USE_DEPRECATED
639 #pragma GCC diagnostic push
640 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
641 template<typename _Tp1
>
643 operator=(std::auto_ptr
<_Tp1
>& __r
)
645 __shared_ptr(__r
).swap(*this);
648 #pragma GCC diagnostic pop
652 reset() // never throws
653 { __shared_ptr().swap(*this); }
655 template<typename _Tp1
>
657 reset(_Tp1
* __p
) // _Tp1 must be complete.
659 // Catch self-reset errors.
660 _GLIBCXX_DEBUG_ASSERT(__p
== 0 || __p
!= _M_ptr
);
661 __shared_ptr(__p
).swap(*this);
664 template<typename _Tp1
, typename _Deleter
>
666 reset(_Tp1
* __p
, _Deleter __d
)
667 { __shared_ptr(__p
, __d
).swap(*this); }
669 // Allow class instantiation when _Tp is [cv-qual] void.
670 typename
std::tr1::add_reference
<_Tp
>::type
671 operator*() const // never throws
673 _GLIBCXX_DEBUG_ASSERT(_M_ptr
!= 0);
678 operator->() const // never throws
680 _GLIBCXX_DEBUG_ASSERT(_M_ptr
!= 0);
685 get() const // never throws
688 // Implicit conversion to "bool"
690 typedef _Tp
* __shared_ptr::*__unspecified_bool_type
;
693 operator __unspecified_bool_type() const // never throws
694 { return _M_ptr
== 0 ? 0 : &__shared_ptr::_M_ptr
; }
697 unique() const // never throws
698 { return _M_refcount
._M_unique(); }
701 use_count() const // never throws
702 { return _M_refcount
._M_get_use_count(); }
705 swap(__shared_ptr
<_Tp
, _Lp
>& __other
) // never throws
707 std::swap(_M_ptr
, __other
._M_ptr
);
708 _M_refcount
._M_swap(__other
._M_refcount
);
713 _M_get_deleter(const std::type_info
& __ti
) const
714 { return _M_refcount
._M_get_deleter(__ti
); }
716 template<typename _Tp1
, _Lock_policy _Lp1
>
718 _M_less(const __shared_ptr
<_Tp1
, _Lp1
>& __rhs
) const
719 { return _M_refcount
< __rhs
._M_refcount
; }
721 template<typename _Tp1
, _Lock_policy _Lp1
> friend class __shared_ptr
;
722 template<typename _Tp1
, _Lock_policy _Lp1
> friend class __weak_ptr
;
724 template<typename _Del
, typename _Tp1
, _Lock_policy _Lp1
>
725 friend _Del
* get_deleter(const __shared_ptr
<_Tp1
, _Lp1
>&);
727 // Friends injected into enclosing namespace and found by ADL:
728 template<typename _Tp1
>
730 operator==(const __shared_ptr
& __a
, const __shared_ptr
<_Tp1
, _Lp
>& __b
)
731 { return __a
.get() == __b
.get(); }
733 template<typename _Tp1
>
735 operator!=(const __shared_ptr
& __a
, const __shared_ptr
<_Tp1
, _Lp
>& __b
)
736 { return __a
.get() != __b
.get(); }
738 template<typename _Tp1
>
740 operator<(const __shared_ptr
& __a
, const __shared_ptr
<_Tp1
, _Lp
>& __b
)
741 { return __a
._M_less(__b
); }
743 _Tp
* _M_ptr
; // Contained pointer.
744 __shared_count
<_Lp
> _M_refcount
; // Reference counter.
747 // 2.2.3.8 shared_ptr specialized algorithms.
748 template<typename _Tp
, _Lock_policy _Lp
>
750 swap(__shared_ptr
<_Tp
, _Lp
>& __a
, __shared_ptr
<_Tp
, _Lp
>& __b
)
753 // 2.2.3.9 shared_ptr casts
754 /* The seemingly equivalent
755 * shared_ptr<_Tp, _Lp>(static_cast<_Tp*>(__r.get()))
756 * will eventually result in undefined behaviour,
757 * attempting to delete the same object twice.
759 template<typename _Tp
, typename _Tp1
, _Lock_policy _Lp
>
760 inline __shared_ptr
<_Tp
, _Lp
>
761 static_pointer_cast(const __shared_ptr
<_Tp1
, _Lp
>& __r
)
762 { return __shared_ptr
<_Tp
, _Lp
>(__r
, __static_cast_tag()); }
764 /* The seemingly equivalent
765 * shared_ptr<_Tp, _Lp>(const_cast<_Tp*>(__r.get()))
766 * will eventually result in undefined behaviour,
767 * attempting to delete the same object twice.
769 template<typename _Tp
, typename _Tp1
, _Lock_policy _Lp
>
770 inline __shared_ptr
<_Tp
, _Lp
>
771 const_pointer_cast(const __shared_ptr
<_Tp1
, _Lp
>& __r
)
772 { return __shared_ptr
<_Tp
, _Lp
>(__r
, __const_cast_tag()); }
774 /* The seemingly equivalent
775 * shared_ptr<_Tp, _Lp>(dynamic_cast<_Tp*>(__r.get()))
776 * will eventually result in undefined behaviour,
777 * attempting to delete the same object twice.
779 template<typename _Tp
, typename _Tp1
, _Lock_policy _Lp
>
780 inline __shared_ptr
<_Tp
, _Lp
>
781 dynamic_pointer_cast(const __shared_ptr
<_Tp1
, _Lp
>& __r
)
782 { return __shared_ptr
<_Tp
, _Lp
>(__r
, __dynamic_cast_tag()); }
784 // 2.2.3.7 shared_ptr I/O
785 template<typename _Ch
, typename _Tr
, typename _Tp
, _Lock_policy _Lp
>
786 std::basic_ostream
<_Ch
, _Tr
>&
787 operator<<(std::basic_ostream
<_Ch
, _Tr
>& __os
,
788 const __shared_ptr
<_Tp
, _Lp
>& __p
)
794 // 2.2.3.10 shared_ptr get_deleter (experimental)
795 template<typename _Del
, typename _Tp
, _Lock_policy _Lp
>
797 get_deleter(const __shared_ptr
<_Tp
, _Lp
>& __p
)
800 return static_cast<_Del
*>(__p
._M_get_deleter(typeid(_Del
)));
807 template<typename _Tp
, _Lock_policy _Lp
>
811 typedef _Tp element_type
;
814 : _M_ptr(0), _M_refcount() // never throws
817 // Generated copy constructor, assignment, destructor are fine.
819 // The "obvious" converting constructor implementation:
821 // template<typename _Tp1>
822 // __weak_ptr(const __weak_ptr<_Tp1, _Lp>& __r)
823 // : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) // never throws
826 // has a serious problem.
828 // __r._M_ptr may already have been invalidated. The _M_ptr(__r._M_ptr)
829 // conversion may require access to *__r._M_ptr (virtual inheritance).
831 // It is not possible to avoid spurious access violations since
832 // in multithreaded programs __r._M_ptr may be invalidated at any point.
833 template<typename _Tp1
>
834 __weak_ptr(const __weak_ptr
<_Tp1
, _Lp
>& __r
)
835 : _M_refcount(__r
._M_refcount
) // never throws
837 __glibcxx_function_requires(_ConvertibleConcept
<_Tp1
*, _Tp
*>)
838 _M_ptr
= __r
.lock().get();
841 template<typename _Tp1
>
842 __weak_ptr(const __shared_ptr
<_Tp1
, _Lp
>& __r
)
843 : _M_ptr(__r
._M_ptr
), _M_refcount(__r
._M_refcount
) // never throws
844 { __glibcxx_function_requires(_ConvertibleConcept
<_Tp1
*, _Tp
*>) }
846 template<typename _Tp1
>
848 operator=(const __weak_ptr
<_Tp1
, _Lp
>& __r
) // never throws
850 _M_ptr
= __r
.lock().get();
851 _M_refcount
= __r
._M_refcount
;
855 template<typename _Tp1
>
857 operator=(const __shared_ptr
<_Tp1
, _Lp
>& __r
) // never throws
860 _M_refcount
= __r
._M_refcount
;
864 __shared_ptr
<_Tp
, _Lp
>
865 lock() const // never throws
868 // Optimization: avoid throw overhead.
870 return __shared_ptr
<element_type
, _Lp
>();
874 return __shared_ptr
<element_type
, _Lp
>(*this);
876 __catch(const bad_weak_ptr
&)
878 // Q: How can we get here?
879 // A: Another thread may have invalidated r after the
880 // use_count test above.
881 return __shared_ptr
<element_type
, _Lp
>();
885 // Optimization: avoid try/catch overhead when single threaded.
886 return expired() ? __shared_ptr
<element_type
, _Lp
>()
887 : __shared_ptr
<element_type
, _Lp
>(*this);
893 use_count() const // never throws
894 { return _M_refcount
._M_get_use_count(); }
897 expired() const // never throws
898 { return _M_refcount
._M_get_use_count() == 0; }
901 reset() // never throws
902 { __weak_ptr().swap(*this); }
905 swap(__weak_ptr
& __s
) // never throws
907 std::swap(_M_ptr
, __s
._M_ptr
);
908 _M_refcount
._M_swap(__s
._M_refcount
);
912 // Used by __enable_shared_from_this.
914 _M_assign(_Tp
* __ptr
, const __shared_count
<_Lp
>& __refcount
)
917 _M_refcount
= __refcount
;
920 template<typename _Tp1
>
922 _M_less(const __weak_ptr
<_Tp1
, _Lp
>& __rhs
) const
923 { return _M_refcount
< __rhs
._M_refcount
; }
925 template<typename _Tp1
, _Lock_policy _Lp1
> friend class __shared_ptr
;
926 template<typename _Tp1
, _Lock_policy _Lp1
> friend class __weak_ptr
;
927 friend class __enable_shared_from_this
<_Tp
, _Lp
>;
928 friend class enable_shared_from_this
<_Tp
>;
930 // Friend injected into namespace and found by ADL.
931 template<typename _Tp1
>
933 operator<(const __weak_ptr
& __lhs
, const __weak_ptr
<_Tp1
, _Lp
>& __rhs
)
934 { return __lhs
._M_less(__rhs
); }
936 _Tp
* _M_ptr
; // Contained pointer.
937 __weak_count
<_Lp
> _M_refcount
; // Reference counter.
940 // 2.2.4.7 weak_ptr specialized algorithms.
941 template<typename _Tp
, _Lock_policy _Lp
>
943 swap(__weak_ptr
<_Tp
, _Lp
>& __a
, __weak_ptr
<_Tp
, _Lp
>& __b
)
947 template<typename _Tp
, _Lock_policy _Lp
>
948 class __enable_shared_from_this
951 __enable_shared_from_this() { }
953 __enable_shared_from_this(const __enable_shared_from_this
&) { }
955 __enable_shared_from_this
&
956 operator=(const __enable_shared_from_this
&)
959 ~__enable_shared_from_this() { }
962 __shared_ptr
<_Tp
, _Lp
>
964 { return __shared_ptr
<_Tp
, _Lp
>(this->_M_weak_this
); }
966 __shared_ptr
<const _Tp
, _Lp
>
967 shared_from_this() const
968 { return __shared_ptr
<const _Tp
, _Lp
>(this->_M_weak_this
); }
971 template<typename _Tp1
>
973 _M_weak_assign(_Tp1
* __p
, const __shared_count
<_Lp
>& __n
) const
974 { _M_weak_this
._M_assign(__p
, __n
); }
976 template<typename _Tp1
>
978 __enable_shared_from_this_helper(const __shared_count
<_Lp
>& __pn
,
979 const __enable_shared_from_this
* __pe
,
983 __pe
->_M_weak_assign(const_cast<_Tp1
*>(__px
), __pn
);
986 mutable __weak_ptr
<_Tp
, _Lp
> _M_weak_this
;
990 // The actual shared_ptr, with forwarding constructors and
991 // assignment operators.
992 template<typename _Tp
>
994 : public __shared_ptr
<_Tp
>
998 : __shared_ptr
<_Tp
>() { }
1000 template<typename _Tp1
>
1002 shared_ptr(_Tp1
* __p
)
1003 : __shared_ptr
<_Tp
>(__p
) { }
1005 template<typename _Tp1
, typename _Deleter
>
1006 shared_ptr(_Tp1
* __p
, _Deleter __d
)
1007 : __shared_ptr
<_Tp
>(__p
, __d
) { }
1009 template<typename _Tp1
>
1010 shared_ptr(const shared_ptr
<_Tp1
>& __r
)
1011 : __shared_ptr
<_Tp
>(__r
) { }
1013 template<typename _Tp1
>
1015 shared_ptr(const weak_ptr
<_Tp1
>& __r
)
1016 : __shared_ptr
<_Tp
>(__r
) { }
1018 #if (__cplusplus < 201103L) || _GLIBCXX_USE_DEPRECATED
1019 #pragma GCC diagnostic push
1020 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
1021 template<typename _Tp1
>
1023 shared_ptr(std::auto_ptr
<_Tp1
>& __r
)
1024 : __shared_ptr
<_Tp
>(__r
) { }
1025 #pragma GCC diagnostic pop
1028 template<typename _Tp1
>
1029 shared_ptr(const shared_ptr
<_Tp1
>& __r
, __static_cast_tag
)
1030 : __shared_ptr
<_Tp
>(__r
, __static_cast_tag()) { }
1032 template<typename _Tp1
>
1033 shared_ptr(const shared_ptr
<_Tp1
>& __r
, __const_cast_tag
)
1034 : __shared_ptr
<_Tp
>(__r
, __const_cast_tag()) { }
1036 template<typename _Tp1
>
1037 shared_ptr(const shared_ptr
<_Tp1
>& __r
, __dynamic_cast_tag
)
1038 : __shared_ptr
<_Tp
>(__r
, __dynamic_cast_tag()) { }
1040 template<typename _Tp1
>
1042 operator=(const shared_ptr
<_Tp1
>& __r
) // never throws
1044 this->__shared_ptr
<_Tp
>::operator=(__r
);
1048 #if (__cplusplus < 201103L) || _GLIBCXX_USE_DEPRECATED
1049 #pragma GCC diagnostic push
1050 #pragma GCC diagnostic ignored "-Wdeprecated-declarations"
1051 template<typename _Tp1
>
1053 operator=(std::auto_ptr
<_Tp1
>& __r
)
1055 this->__shared_ptr
<_Tp
>::operator=(__r
);
1058 #pragma GCC diagnostic pop
1062 // 2.2.3.8 shared_ptr specialized algorithms.
1063 template<typename _Tp
>
1065 swap(__shared_ptr
<_Tp
>& __a
, __shared_ptr
<_Tp
>& __b
)
1068 template<typename _Tp
, typename _Tp1
>
1069 inline shared_ptr
<_Tp
>
1070 static_pointer_cast(const shared_ptr
<_Tp1
>& __r
)
1071 { return shared_ptr
<_Tp
>(__r
, __static_cast_tag()); }
1073 template<typename _Tp
, typename _Tp1
>
1074 inline shared_ptr
<_Tp
>
1075 const_pointer_cast(const shared_ptr
<_Tp1
>& __r
)
1076 { return shared_ptr
<_Tp
>(__r
, __const_cast_tag()); }
1078 template<typename _Tp
, typename _Tp1
>
1079 inline shared_ptr
<_Tp
>
1080 dynamic_pointer_cast(const shared_ptr
<_Tp1
>& __r
)
1081 { return shared_ptr
<_Tp
>(__r
, __dynamic_cast_tag()); }
1084 // The actual weak_ptr, with forwarding constructors and
1085 // assignment operators.
1086 template<typename _Tp
>
1088 : public __weak_ptr
<_Tp
>
1092 : __weak_ptr
<_Tp
>() { }
1094 template<typename _Tp1
>
1095 weak_ptr(const weak_ptr
<_Tp1
>& __r
)
1096 : __weak_ptr
<_Tp
>(__r
) { }
1098 template<typename _Tp1
>
1099 weak_ptr(const shared_ptr
<_Tp1
>& __r
)
1100 : __weak_ptr
<_Tp
>(__r
) { }
1102 template<typename _Tp1
>
1104 operator=(const weak_ptr
<_Tp1
>& __r
) // never throws
1106 this->__weak_ptr
<_Tp
>::operator=(__r
);
1110 template<typename _Tp1
>
1112 operator=(const shared_ptr
<_Tp1
>& __r
) // never throws
1114 this->__weak_ptr
<_Tp
>::operator=(__r
);
1119 lock() const // never throws
1122 if (this->expired())
1123 return shared_ptr
<_Tp
>();
1127 return shared_ptr
<_Tp
>(*this);
1129 __catch(const bad_weak_ptr
&)
1131 return shared_ptr
<_Tp
>();
1134 return this->expired() ? shared_ptr
<_Tp
>()
1135 : shared_ptr
<_Tp
>(*this);
1140 template<typename _Tp
>
1141 class enable_shared_from_this
1144 enable_shared_from_this() { }
1146 enable_shared_from_this(const enable_shared_from_this
&) { }
1148 enable_shared_from_this
&
1149 operator=(const enable_shared_from_this
&)
1152 ~enable_shared_from_this() { }
1157 { return shared_ptr
<_Tp
>(this->_M_weak_this
); }
1159 shared_ptr
<const _Tp
>
1160 shared_from_this() const
1161 { return shared_ptr
<const _Tp
>(this->_M_weak_this
); }
1164 template<typename _Tp1
>
1166 _M_weak_assign(_Tp1
* __p
, const __shared_count
<>& __n
) const
1167 { _M_weak_this
._M_assign(__p
, __n
); }
1169 template<typename _Tp1
>
1171 __enable_shared_from_this_helper(const __shared_count
<>& __pn
,
1172 const enable_shared_from_this
* __pe
,
1176 __pe
->_M_weak_assign(const_cast<_Tp1
*>(__px
), __pn
);
1179 mutable weak_ptr
<_Tp
> _M_weak_this
;
1183 _GLIBCXX_END_NAMESPACE_VERSION
1186 #endif // _TR1_SHARED_PTR_H