30 #ifndef _GLIBCXX_EXPERIMENTAL_SHARED_PTR_H 31 #define _GLIBCXX_EXPERIMENTAL_SHARED_PTR_H 1 33 #pragma GCC system_header 35 #if __cplusplus <= 201103L 42 namespace std _GLIBCXX_VISIBILITY(default)
44 namespace experimental
46 inline namespace fundamentals_v2
48 _GLIBCXX_BEGIN_NAMESPACE_VERSION
49 template<
typename _Tp>
class enable_shared_from_this;
50 _GLIBCXX_END_NAMESPACE_VERSION
54 #define __cpp_lib_experimental_shared_ptr_arrays 201406 56 _GLIBCXX_BEGIN_NAMESPACE_VERSION
69 template <typename _Tp, bool = is_array<_Tp>::value>
70 struct __libfund_v1 {
using type = _Tp; };
74 template<
typename _Tp, _Lock_policy _Lp>
75 class __shared_ptr<__libfund_v1<_Tp, false>, _Lp>
76 :
private __shared_ptr<_Tp, _Lp>
79 template<
typename _Yp,
typename _Res =
void>
81 = enable_if_t<experimental::is_convertible_v<_Yp*, _Tp*>, _Res>;
83 template<
typename _Yp,
typename _Del,
84 typename _Ptr =
typename unique_ptr<_Yp, _Del>::pointer,
86 using _UniqCompatible = enable_if_t<
87 experimental::is_convertible_v<_Yp*, _Tp*>
88 && experimental::is_convertible_v<_Ptr, _Tp*>,
91 using _Base_type = __shared_ptr<_Tp>;
93 _Base_type& _M_get_base() {
return *
this; }
94 const _Base_type& _M_get_base()
const {
return *
this; }
97 using element_type = _Tp;
99 constexpr __shared_ptr() noexcept = default;
101 template<typename _Tp1, typename = _Compatible<_Tp1>>
103 __shared_ptr(_Tp1* __p)
107 template<
typename _Tp1,
typename _Deleter,
typename = _Compatible<_Tp1>>
108 __shared_ptr(_Tp1* __p, _Deleter __d)
109 : _Base_type(__p, __d)
112 template<
typename _Tp1,
typename _Deleter,
typename _Alloc,
113 typename = _Compatible<_Tp1>>
114 __shared_ptr(_Tp1* __p, _Deleter __d, _Alloc __a)
115 : _Base_type(__p, __d, __a)
118 template<
typename _Deleter>
119 __shared_ptr(nullptr_t __p, _Deleter __d)
120 : _Base_type(__p, __d)
123 template<
typename _Deleter,
typename _Alloc>
124 __shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a)
125 : _Base_type(__p, __d, __a)
128 template<
typename _Tp1>
129 __shared_ptr(
const __shared_ptr<__libfund_v1<_Tp1>, _Lp>& __r,
130 element_type* __p) noexcept
131 : _Base_type(__r._M_get_base(), __p)
134 __shared_ptr(
const __shared_ptr&) noexcept = default;
135 __shared_ptr(__shared_ptr&&) noexcept = default;
136 __shared_ptr& operator=(const __shared_ptr&) noexcept = default;
137 __shared_ptr& operator=(__shared_ptr&&) noexcept = default;
138 ~__shared_ptr() = default;
140 template<typename _Tp1, typename = _Compatible<_Tp1>>
141 __shared_ptr(const __shared_ptr<__libfund_v1<_Tp1>, _Lp>& __r) noexcept
142 : _Base_type(__r._M_get_base())
145 template<
typename _Tp1,
typename = _Compatible<_Tp1>>
146 __shared_ptr(__shared_ptr<__libfund_v1<_Tp1>, _Lp>&& __r) noexcept
147 : _Base_type(
std::move((__r._M_get_base())))
150 template<
typename _Tp1,
typename = _Compatible<_Tp1>>
152 __shared_ptr(
const __weak_ptr<__libfund_v1<_Tp1>, _Lp>& __r)
153 : _Base_type(__r._M_get_base())
156 template<
typename _Tp1,
typename _Del,
157 typename = _UniqCompatible<_Tp1, _Del>>
158 __shared_ptr(unique_ptr<_Tp1, _Del>&& __r)
159 : _Base_type(
std::move(__r))
162 #if _GLIBCXX_USE_DEPRECATED 164 template<
typename _Tp1,
typename = _Compatible<_Tp1>>
166 : _Base_type(
std::move(__r))
170 constexpr __shared_ptr(nullptr_t) noexcept : __shared_ptr() { }
175 { __shared_ptr(
nullptr).swap(*
this); }
177 template<
typename _Tp1>
181 _GLIBCXX_DEBUG_ASSERT(__p == 0 || __p !=
get());
182 __shared_ptr(__p).swap(*
this);
185 template<
typename _Tp1,
typename _Deleter>
187 reset(_Tp1* __p, _Deleter __d)
188 { __shared_ptr(__p, __d).swap(*
this); }
190 template<
typename _Tp1,
typename _Deleter,
typename _Alloc>
192 reset(_Tp1* __p, _Deleter __d, _Alloc __a)
193 { __shared_ptr(__p, __d, std::move(__a)).swap(*
this); }
195 using _Base_type::operator*;
196 using _Base_type::operator->;
198 template<
typename _Tp1>
199 _Compatible<_Tp1, __shared_ptr&>
200 operator=(
const __shared_ptr<__libfund_v1<_Tp1>, _Lp>& __r) noexcept
202 _Base_type::operator=(__r._M_get_base());
207 _Compatible<_Tp1, __shared_ptr&>
208 operator=(__shared_ptr<__libfund_v1<_Tp1>, _Lp>&& __r) noexcept
210 _Base_type::operator=(std::move(__r._M_get_base()));
214 template<
typename _Tp1,
typename _Del>
215 _UniqCompatible<_Tp1, _Del, __shared_ptr&>
216 operator=(unique_ptr<_Tp1, _Del>&& __r)
218 _Base_type::operator=(std::move(__r));
222 #if _GLIBCXX_USE_DEPRECATED 223 template<
typename _Tp1>
224 _Compatible<_Tp1, __shared_ptr&>
227 _Base_type::operator=(std::move(__r));
233 swap(__shared_ptr& __other) noexcept
234 { _Base_type::swap(__other); }
236 template<
typename _Tp1>
238 owner_before(__shared_ptr<__libfund_v1<_Tp1>, _Lp>
const& __rhs)
const 239 {
return _Base_type::owner_before(__rhs._M_get_base()); }
241 template<
typename _Tp1>
243 owner_before(__weak_ptr<__libfund_v1<_Tp1>, _Lp>
const& __rhs)
const 244 {
return _Base_type::owner_before(__rhs._M_get_base()); }
246 using _Base_type::operator bool;
247 using _Base_type::get;
248 using _Base_type::unique;
249 using _Base_type::use_count;
266 __shared_ptr(
const __weak_ptr<__libfund_v1<_Tp>, _Lp>& __r,
268 : _Base_type(__r._M_get_base(),
std::nothrow)
272 template<
typename _Tp1, _Lock_policy _Lp1>
friend class __weak_ptr;
273 template<
typename _Tp1, _Lock_policy _Lp1>
friend class __shared_ptr;
276 template<
typename _Del,
typename _Tp1, _Lock_policy _Lp1>
277 friend _Del*
get_deleter(
const __shared_ptr<_Tp1, _Lp1>&) noexcept;
283 template<typename _Yp, typename _Tp>
284 struct __sp_compatible
285 : is_convertible<_Yp*, _Tp*>::type
288 template<
size_t _Nm,
typename _Tp>
289 struct __sp_compatible<_Tp[_Nm], _Tp[]>
293 template<
size_t _Nm,
typename _Tp>
294 struct __sp_compatible<_Tp[_Nm], const _Tp[]>
298 template<
typename _Yp,
typename _Tp>
299 constexpr
bool __sp_compatible_v
300 = __sp_compatible<_Yp, _Tp>::value;
303 template<
typename _Up,
size_t _Nm,
typename _Yp,
typename =
void>
304 struct __sp_is_constructible_arrN
308 template<
typename _Up,
size_t _Nm,
typename _Yp>
309 struct __sp_is_constructible_arrN<_Up, _Nm, _Yp, __void_t<_Yp[_Nm]>>
310 : is_convertible<_Yp(*)[_Nm], _Up(*)[_Nm]>::type
314 template<
typename _Up,
typename _Yp,
typename =
void>
315 struct __sp_is_constructible_arr
319 template<
typename _Up,
typename _Yp>
320 struct __sp_is_constructible_arr<_Up, _Yp, __void_t<_Yp[]>>
321 : is_convertible<_Yp(*)[], _Up(*)[]>::type
325 template<
typename _Tp,
typename _Yp>
326 struct __sp_is_constructible;
329 template<
typename _Up,
size_t _Nm,
typename _Yp>
330 struct __sp_is_constructible<_Up[_Nm], _Yp>
331 : __sp_is_constructible_arrN<_Up, _Nm, _Yp>::type
335 template<
typename _Up,
typename _Yp>
336 struct __sp_is_constructible<_Up[], _Yp>
337 : __sp_is_constructible_arr<_Up, _Yp>::type
341 template<
typename _Tp,
typename _Yp>
342 struct __sp_is_constructible
343 : is_convertible<_Yp*, _Tp*>::type
346 template<
typename _Tp,
typename _Yp>
347 constexpr
bool __sp_is_constructible_v
348 = __sp_is_constructible<_Tp, _Yp>::value;
353 template<
typename _Tp, _Lock_policy _Lp>
354 class __shared_ptr<__libfund_v1<_Tp, true>, _Lp>
355 :
private __shared_ptr<remove_extent_t<_Tp>, _Lp>
358 using element_type = remove_extent_t<_Tp>;
361 struct _Array_deleter
364 operator()(element_type
const *__p)
const 369 template<
typename _Yp>
370 using _SafeConv = enable_if_t<__sp_is_constructible_v<_Tp, _Yp>>;
373 template<
typename _Tp1,
typename _Res =
void>
374 using _Compatible = enable_if_t<__sp_compatible_v<_Tp1, _Tp>, _Res>;
377 template<
typename _Tp1,
typename _Del,
378 typename _Ptr =
typename unique_ptr<_Tp1, _Del>::pointer,
379 typename _Res =
void>
380 using _UniqCompatible = enable_if_t<
381 __sp_compatible_v<_Tp1, _Tp>
382 && experimental::is_convertible_v<_Ptr, element_type*>,
385 using _Base_type = __shared_ptr<element_type>;
387 _Base_type& _M_get_base() {
return *
this; }
388 const _Base_type& _M_get_base()
const {
return *
this; }
391 constexpr __shared_ptr() noexcept
395 template<
typename _Tp1,
typename = _SafeConv<_Tp1>>
397 __shared_ptr(_Tp1* __p)
398 : _Base_type(__p, _Array_deleter())
401 template<
typename _Tp1,
typename _Deleter,
typename = _SafeConv<_Tp1>>
402 __shared_ptr(_Tp1* __p, _Deleter __d)
403 : _Base_type(__p, __d)
406 template<
typename _Tp1,
typename _Deleter,
typename _Alloc,
407 typename = _SafeConv<_Tp1>>
408 __shared_ptr(_Tp1* __p, _Deleter __d, _Alloc __a)
409 : _Base_type(__p, __d, __a)
412 template<
typename _Deleter>
413 __shared_ptr(nullptr_t __p, _Deleter __d)
414 : _Base_type(__p, __d)
417 template<
typename _Deleter,
typename _Alloc>
418 __shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a)
419 : _Base_type(__p, __d, __a)
422 template<
typename _Tp1>
423 __shared_ptr(
const __shared_ptr<__libfund_v1<_Tp1>, _Lp>& __r,
424 element_type* __p) noexcept
425 : _Base_type(__r._M_get_base(), __p)
428 __shared_ptr(
const __shared_ptr&) noexcept = default;
429 __shared_ptr(__shared_ptr&&) noexcept = default;
430 __shared_ptr& operator=(const __shared_ptr&) noexcept = default;
431 __shared_ptr& operator=(__shared_ptr&&) noexcept = default;
432 ~__shared_ptr() = default;
434 template<typename _Tp1, typename = _Compatible<_Tp1>>
435 __shared_ptr(const __shared_ptr<__libfund_v1<_Tp1>, _Lp>& __r) noexcept
436 : _Base_type(__r._M_get_base())
439 template<
typename _Tp1,
typename = _Compatible<_Tp1>>
440 __shared_ptr(__shared_ptr<__libfund_v1<_Tp1>, _Lp>&& __r) noexcept
441 : _Base_type(
std::move((__r._M_get_base())))
444 template<
typename _Tp1,
typename = _Compatible<_Tp1>>
446 __shared_ptr(
const __weak_ptr<__libfund_v1<_Tp1>, _Lp>& __r)
447 : _Base_type(__r._M_get_base())
450 template<
typename _Tp1,
typename _Del,
451 typename = _UniqCompatible<_Tp1, _Del>>
452 __shared_ptr(unique_ptr<_Tp1, _Del>&& __r)
453 : _Base_type(
std::move(__r))
456 #if _GLIBCXX_USE_DEPRECATED 458 template<
typename _Tp1,
typename = _Compatible<_Tp1>>
459 __shared_ptr(auto_ptr<_Tp1>&& __r)
460 : _Base_type(
std::move(__r))
464 constexpr __shared_ptr(nullptr_t) noexcept : __shared_ptr() { }
469 { __shared_ptr(
nullptr).swap(*
this); }
471 template<
typename _Tp1>
475 _GLIBCXX_DEBUG_ASSERT(__p == 0 || __p !=
get());
476 __shared_ptr(__p, _Array_deleter()).swap(*
this);
479 template<
typename _Tp1,
typename _Deleter>
481 reset(_Tp1* __p, _Deleter __d)
482 { __shared_ptr(__p, __d).swap(*
this); }
484 template<
typename _Tp1,
typename _Deleter,
typename _Alloc>
486 reset(_Tp1* __p, _Deleter __d, _Alloc __a)
487 { __shared_ptr(__p, __d, std::move(__a)).swap(*
this); }
490 operator[](ptrdiff_t i)
const noexcept
492 _GLIBCXX_DEBUG_ASSERT(
get() != 0 && i >= 0);
496 template<
typename _Tp1>
497 _Compatible<_Tp1, __shared_ptr&>
498 operator=(
const __shared_ptr<__libfund_v1<_Tp1>, _Lp>& __r) noexcept
500 _Base_type::operator=(__r._M_get_base());
505 _Compatible<_Tp1, __shared_ptr&>
506 operator=(__shared_ptr<__libfund_v1<_Tp1>, _Lp>&& __r) noexcept
508 _Base_type::operator=(std::move(__r._M_get_base()));
512 template<
typename _Tp1,
typename _Del>
513 _UniqCompatible<_Tp1, _Del, __shared_ptr&>
514 operator=(unique_ptr<_Tp1, _Del>&& __r)
516 _Base_type::operator=(std::move(__r));
520 #if _GLIBCXX_USE_DEPRECATED 521 template<
typename _Tp1>
522 _Compatible<_Tp1, __shared_ptr&>
523 operator=(auto_ptr<_Tp1>&& __r)
525 _Base_type::operator=(std::move(__r));
531 swap(__shared_ptr& __other) noexcept
532 { _Base_type::swap(__other); }
534 template<
typename _Tp1>
536 owner_before(__shared_ptr<__libfund_v1<_Tp1>, _Lp>
const& __rhs)
const 537 {
return _Base_type::owner_before(__rhs._M_get_base()); }
539 template<
typename _Tp1>
541 owner_before(__weak_ptr<__libfund_v1<_Tp1>, _Lp>
const& __rhs)
const 542 {
return _Base_type::owner_before(__rhs._M_get_base()); }
544 using _Base_type::operator bool;
545 using _Base_type::get;
546 using _Base_type::unique;
547 using _Base_type::use_count;
564 __shared_ptr(
const __weak_ptr<__libfund_v1<_Tp>, _Lp>& __r,
566 : _Base_type(__r._M_get_base(),
std::nothrow)
570 template<
typename _Tp1, _Lock_policy _Lp1>
friend class __weak_ptr;
571 template<
typename _Tp1, _Lock_policy _Lp1>
friend class __shared_ptr;
574 template<
typename _Del,
typename _Tp1, _Lock_policy _Lp1>
575 friend _Del*
get_deleter(
const __shared_ptr<_Tp1, _Lp1>&) noexcept;
579 template<typename _Tp, _Lock_policy _Lp>
580 class __weak_ptr<__libfund_v1<_Tp>, _Lp>
581 : __weak_ptr<remove_extent_t<_Tp>, _Lp>
583 template<
typename _Tp1,
typename _Res =
void>
585 = enable_if_t<__sp_compatible_v<_Tp1, _Tp>, _Res>;
587 using _Base_type = __weak_ptr<remove_extent_t<_Tp>>;
589 _Base_type& _M_get_base() {
return *
this; }
590 const _Base_type& _M_get_base()
const {
return *
this; }
593 using element_type = remove_extent_t<_Tp>;
595 constexpr __weak_ptr() noexcept
599 __weak_ptr(
const __weak_ptr&) noexcept = default;
601 ~__weak_ptr() = default;
603 template<typename _Tp1, typename = _Compatible<_Tp1>>
604 __weak_ptr(const __weak_ptr<__libfund_v1<_Tp1>, _Lp>& __r) noexcept
605 : _Base_type(__r._M_get_base())
608 template<
typename _Tp1,
typename = _Compatible<_Tp1>>
609 __weak_ptr(
const __shared_ptr<__libfund_v1<_Tp1>, _Lp>& __r) noexcept
610 : _Base_type(__r._M_get_base())
613 __weak_ptr(__weak_ptr&& __r) noexcept
614 : _Base_type(
std::move(__r))
617 template<
typename _Tp1,
typename = _Compatible<_Tp1>>
618 __weak_ptr(__weak_ptr<__libfund_v1<_Tp1>, _Lp>&& __r) noexcept
619 : _Base_type(
std::move(__r._M_get_base()))
623 operator=(
const __weak_ptr& __r) noexcept =
default;
625 template<
typename _Tp1>
626 _Compatible<_Tp1, __weak_ptr&>
627 operator=(
const __weak_ptr<__libfund_v1<_Tp1>, _Lp>& __r) noexcept
629 this->_Base_type::operator=(__r._M_get_base());
633 template<
typename _Tp1>
634 _Compatible<_Tp1, __weak_ptr&>
635 operator=(
const __shared_ptr<_Tp1, _Lp>& __r) noexcept
637 this->_Base_type::operator=(__r._M_get_base());
642 operator=(__weak_ptr&& __r) noexcept
644 this->_Base_type::operator=(std::move(__r));
648 template<
typename _Tp1>
649 _Compatible<_Tp1, __weak_ptr&>
650 operator=(__weak_ptr<_Tp1, _Lp>&& __r) noexcept
652 this->_Base_type::operator=(std::move(__r._M_get_base()));
657 swap(__weak_ptr& __other) noexcept
658 { this->_Base_type::swap(__other); }
660 template<
typename _Tp1>
662 owner_before(
const __shared_ptr<__libfund_v1<_Tp1>, _Lp>& __rhs)
const 663 {
return _Base_type::owner_before(__rhs._M_get_base()); }
665 template<
typename _Tp1>
667 owner_before(
const __weak_ptr<__libfund_v1<_Tp1>, _Lp>& __rhs)
const 668 {
return _Base_type::owner_before(__rhs._M_get_base()); }
670 __shared_ptr<__libfund_v1<_Tp>, _Lp>
671 lock() const noexcept
672 {
return __shared_ptr<__libfund_v1<_Tp>, _Lp>(*
this, std::nothrow); }
674 using _Base_type::use_count;
675 using _Base_type::expired;
676 using _Base_type::reset;
681 _M_assign(element_type* __ptr,
682 const __shared_count<_Lp>& __refcount) noexcept
683 { this->_Base_type::_M_assign(__ptr, __refcount); }
685 template<
typename _Tp1, _Lock_policy _Lp1>
friend class __shared_ptr;
686 template<
typename _Tp1, _Lock_policy _Lp1>
friend class __weak_ptr;
687 friend class __enable_shared_from_this<_Tp, _Lp>;
688 friend class experimental::enable_shared_from_this<_Tp>;
689 friend class enable_shared_from_this<_Tp>;
692 _GLIBCXX_END_NAMESPACE_VERSION
694 namespace experimental
696 inline namespace fundamentals_v2
698 _GLIBCXX_BEGIN_NAMESPACE_VERSION
702 template<
typename _Tp>
class shared_ptr;
703 template<
typename _Tp>
class weak_ptr;
705 template<
typename _Tp, _Lock_policy _Lp = __default_lock_policy>
706 using __shared_ptr = std::__shared_ptr<__libfund_v1<_Tp>, _Lp>;
708 template<
typename _Tp, _Lock_policy _Lp = __default_lock_policy>
709 using __weak_ptr = std::__weak_ptr<__libfund_v1<_Tp>, _Lp>;
711 template<
typename _Tp>
712 class shared_ptr :
public __shared_ptr<_Tp>
714 using _Base_type = __shared_ptr<_Tp>;
717 using element_type =
typename _Base_type::element_type;
721 template<
typename _Yp>
722 using _SafeConv = enable_if_t<__sp_is_constructible_v<_Tp, _Yp>>;
724 template<
typename _Tp1,
typename _Res =
void>
726 = enable_if_t<__sp_compatible_v<_Tp1, _Tp>, _Res>;
728 template<
typename _Tp1,
typename _Del,
729 typename _Ptr =
typename unique_ptr<_Tp1, _Del>::pointer,
730 typename _Res =
void>
731 using _UniqCompatible = enable_if_t<
732 __sp_compatible_v<_Tp1, _Tp>
733 && experimental::is_convertible_v<_Ptr, element_type*>,
739 constexpr shared_ptr() noexcept = default;
741 template<typename _Tp1, typename = _SafeConv<_Tp1>>
743 shared_ptr(_Tp1* __p) : _Base_type(__p) { }
745 template<
typename _Tp1,
typename _Deleter,
typename = _SafeConv<_Tp1>>
746 shared_ptr(_Tp1* __p, _Deleter __d)
747 : _Base_type(__p, __d) { }
749 template<
typename _Tp1,
typename _Deleter,
typename _Alloc,
750 typename = _SafeConv<_Tp1>>
751 shared_ptr(_Tp1* __p, _Deleter __d, _Alloc __a)
752 : _Base_type(__p, __d, __a) { }
754 template<
typename _Deleter>
755 shared_ptr(nullptr_t __p, _Deleter __d)
756 : _Base_type(__p, __d) { }
758 template<
typename _Deleter,
typename _Alloc>
759 shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a)
760 : _Base_type(__p, __d, __a) { }
762 template<
typename _Tp1>
763 shared_ptr(
const shared_ptr<_Tp1>& __r, element_type* __p) noexcept
764 : _Base_type(__r, __p) { }
766 shared_ptr(
const shared_ptr& __r) noexcept
767 : _Base_type(__r) { }
769 template<
typename _Tp1,
typename = _Compatible<_Tp1>>
770 shared_ptr(
const shared_ptr<_Tp1>& __r) noexcept
771 : _Base_type(__r) { }
773 shared_ptr(shared_ptr&& __r) noexcept
774 : _Base_type(
std::move(__r)) { }
776 template<
typename _Tp1,
typename = _Compatible<_Tp1>>
777 shared_ptr(shared_ptr<_Tp1>&& __r) noexcept
778 : _Base_type(
std::move(__r)) { }
780 template<
typename _Tp1,
typename = _Compatible<_Tp1>>
782 shared_ptr(
const weak_ptr<_Tp1>& __r)
783 : _Base_type(__r) { }
785 #if _GLIBCXX_USE_DEPRECATED 786 template<
typename _Tp1,
typename = _Compatible<_Tp1>>
788 : _Base_type(
std::move(__r)) { }
791 template<
typename _Tp1,
typename _Del,
792 typename = _UniqCompatible<_Tp1, _Del>>
793 shared_ptr(unique_ptr<_Tp1, _Del>&& __r)
794 : _Base_type(
std::move(__r)) { }
796 constexpr shared_ptr(nullptr_t __p)
797 : _Base_type(__p) { }
800 ~shared_ptr() =
default;
803 shared_ptr& operator=(
const shared_ptr&) noexcept = default;
805 template <typename _Tp1>
806 _Compatible<_Tp1, shared_ptr&>
807 operator=(const shared_ptr<_Tp1>& __r) noexcept
809 _Base_type::operator=(__r);
814 operator=(shared_ptr&& __r) noexcept
816 _Base_type::operator=(std::move(__r));
820 template <
typename _Tp1>
821 _Compatible<_Tp1, shared_ptr&>
822 operator=(shared_ptr<_Tp1>&& __r) noexcept
824 _Base_type::operator=(std::move(__r));
828 #if _GLIBCXX_USE_DEPRECATED 829 template<
typename _Tp1>
830 _Compatible<_Tp1, shared_ptr&>
833 __shared_ptr<_Tp>::operator=(std::move(__r));
838 template <
typename _Tp1,
typename _Del>
839 _UniqCompatible<_Tp1, _Del, shared_ptr&>
840 operator=(unique_ptr<_Tp1, _Del>&& __r)
842 _Base_type::operator=(std::move(__r));
852 template<
typename _Alloc,
typename... _Args>
853 shared_ptr(_Sp_make_shared_tag __tag,
const _Alloc& __a,
855 : _Base_type(__tag, __a,
std::
forward<_Args>(__args)...)
858 template<
typename _Tp1,
typename _Alloc,
typename... _Args>
859 friend shared_ptr<_Tp1>
862 shared_ptr(
const weak_ptr<_Tp>& __r, std::nothrow_t)
863 : _Base_type(__r,
std::nothrow) { }
865 friend class weak_ptr<_Tp>;
869 template<
typename _Tp1,
typename _Tp2>
870 bool operator==(
const shared_ptr<_Tp1>& __a,
871 const shared_ptr<_Tp2>& __b) noexcept
872 {
return __a.get() == __b.get(); }
874 template<
typename _Tp>
876 operator==(
const shared_ptr<_Tp>& __a, nullptr_t) noexcept
879 template<
typename _Tp>
881 operator==(nullptr_t,
const shared_ptr<_Tp>& __a) noexcept
884 template<
typename _Tp1,
typename _Tp2>
886 operator!=(
const shared_ptr<_Tp1>& __a,
887 const shared_ptr<_Tp2>& __b) noexcept
888 {
return __a.get() != __b.get(); }
890 template<
typename _Tp>
892 operator!=(
const shared_ptr<_Tp>& __a, nullptr_t) noexcept
893 {
return (
bool)__a; }
895 template<
typename _Tp>
897 operator!=(nullptr_t,
const shared_ptr<_Tp>& __a) noexcept
898 {
return (
bool)__a; }
900 template<
typename _Tp1,
typename _Tp2>
902 operator<(const shared_ptr<_Tp1>& __a,
903 const shared_ptr<_Tp2>& __b) noexcept
905 using __elem_t1 =
typename shared_ptr<_Tp1>::element_type;
906 using __elem_t2 =
typename shared_ptr<_Tp2>::element_type;
907 using _CT = common_type_t<__elem_t1*, __elem_t2*>;
911 template<
typename _Tp>
913 operator<(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
915 using __elem_t =
typename shared_ptr<_Tp>::element_type;
919 template<
typename _Tp>
921 operator<(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
923 using __elem_t =
typename shared_ptr<_Tp>::element_type;
927 template<
typename _Tp1,
typename _Tp2>
929 operator<=(const shared_ptr<_Tp1>& __a,
930 const shared_ptr<_Tp2>& __b) noexcept
931 {
return !(__b < __a); }
933 template<
typename _Tp>
935 operator<=(const shared_ptr<_Tp>& __a, nullptr_t) noexcept
936 {
return !(
nullptr < __a); }
938 template<
typename _Tp>
940 operator<=(nullptr_t, const shared_ptr<_Tp>& __a) noexcept
941 {
return !(__a <
nullptr); }
943 template<
typename _Tp1,
typename _Tp2>
945 operator>(
const shared_ptr<_Tp1>& __a,
946 const shared_ptr<_Tp2>& __b) noexcept
947 {
return (__b < __a); }
949 template<
typename _Tp>
951 operator>(
const shared_ptr<_Tp>& __a, nullptr_t) noexcept
953 using __elem_t =
typename shared_ptr<_Tp>::element_type;
957 template<
typename _Tp>
959 operator>(nullptr_t,
const shared_ptr<_Tp>& __a) noexcept
961 using __elem_t =
typename shared_ptr<_Tp>::element_type;
965 template<
typename _Tp1,
typename _Tp2>
967 operator>=(
const shared_ptr<_Tp1>& __a,
968 const shared_ptr<_Tp2>& __b) noexcept
969 {
return !(__a < __b); }
971 template<
typename _Tp>
973 operator>=(
const shared_ptr<_Tp>& __a, nullptr_t) noexcept
974 {
return !(__a <
nullptr); }
976 template<
typename _Tp>
978 operator>=(nullptr_t,
const shared_ptr<_Tp>& __a) noexcept
979 {
return !(
nullptr < __a); }
982 template<
typename _Tp>
984 swap(shared_ptr<_Tp>& __a, shared_ptr<_Tp>& __b) noexcept
988 template<
typename _Tp,
typename _Tp1>
989 inline shared_ptr<_Tp>
990 static_pointer_cast(
const shared_ptr<_Tp1>& __r) noexcept
992 using __elem_t =
typename shared_ptr<_Tp>::element_type;
993 return shared_ptr<_Tp>(__r,
static_cast<__elem_t*
>(__r.get()));
996 template<
typename _Tp,
typename _Tp1>
997 inline shared_ptr<_Tp>
998 dynamic_pointer_cast(
const shared_ptr<_Tp1>& __r) noexcept
1000 using __elem_t =
typename shared_ptr<_Tp>::element_type;
1001 if (_Tp* __p = dynamic_cast<__elem_t*>(__r.get()))
1002 return shared_ptr<_Tp>(__r, __p);
1003 return shared_ptr<_Tp>();
1006 template<
typename _Tp,
typename _Tp1>
1007 inline shared_ptr<_Tp>
1008 const_pointer_cast(
const shared_ptr<_Tp1>& __r) noexcept
1010 using __elem_t =
typename shared_ptr<_Tp>::element_type;
1011 return shared_ptr<_Tp>(__r,
const_cast<__elem_t*
>(__r.get()));
1014 template<
typename _Tp,
typename _Tp1>
1015 inline shared_ptr<_Tp>
1016 reinterpret_pointer_cast(
const shared_ptr<_Tp1>& __r) noexcept
1018 using __elem_t =
typename shared_ptr<_Tp>::element_type;
1019 return shared_ptr<_Tp>(__r,
reinterpret_cast<__elem_t*
>(__r.get()));
1023 template<
typename _Tp>
1024 class weak_ptr :
public __weak_ptr<_Tp>
1026 template<
typename _Tp1,
typename _Res =
void>
1027 using _Compatible = enable_if_t<__sp_compatible_v<_Tp1, _Tp>, _Res>;
1029 using _Base_type = __weak_ptr<_Tp>;
1032 constexpr weak_ptr() noexcept = default;
1034 template<typename _Tp1, typename = _Compatible<_Tp1>>
1035 weak_ptr(const shared_ptr<_Tp1>& __r) noexcept
1036 : _Base_type(__r) { }
1038 weak_ptr(
const weak_ptr&) noexcept = default;
1040 template<typename _Tp1, typename = _Compatible<_Tp1>>
1041 weak_ptr(const weak_ptr<_Tp1>& __r) noexcept
1042 : _Base_type(__r) { }
1044 weak_ptr(weak_ptr&&) noexcept = default;
1046 template<typename _Tp1, typename = _Compatible<_Tp1>>
1047 weak_ptr(weak_ptr<_Tp1>&& __r) noexcept
1048 : _Base_type(
std::move(__r)) { }
1051 operator=(
const weak_ptr& __r) noexcept =
default;
1053 template<
typename _Tp1>
1054 _Compatible<_Tp1, weak_ptr&>
1055 operator=(
const weak_ptr<_Tp1>& __r) noexcept
1057 this->_Base_type::operator=(__r);
1061 template<
typename _Tp1>
1062 _Compatible<_Tp1, weak_ptr&>
1063 operator=(
const shared_ptr<_Tp1>& __r) noexcept
1065 this->_Base_type::operator=(__r);
1070 operator=(weak_ptr&& __r) noexcept = default;
1072 template<typename _Tp1>
1073 _Compatible<_Tp1, weak_ptr&>
1074 operator=(weak_ptr<_Tp1>&& __r) noexcept
1076 this->_Base_type::operator=(std::move(__r));
1081 lock() const noexcept
1082 {
return shared_ptr<_Tp>(*
this, std::nothrow); }
1084 friend class enable_shared_from_this<_Tp>;
1088 template<
typename _Tp>
1090 swap(weak_ptr<_Tp>& __a, weak_ptr<_Tp>& __b) noexcept
1094 template<
typename _Del,
typename _Tp, _Lock_policy _Lp>
1097 {
return std::get_deleter<_Del>(__p); }
1100 template<
typename _Ch,
typename _Tr,
typename _Tp, _Lock_policy _Lp>
1102 operator<<(std::basic_ostream<_Ch, _Tr>& __os,
1103 const __shared_ptr<_Tp, _Lp>& __p)
1110 template<
typename _Tp =
void>
class owner_less;
1113 template<
typename _Tp>
1114 struct owner_less<shared_ptr<_Tp>>
1115 :
public _Sp_owner_less<shared_ptr<_Tp>, weak_ptr<_Tp>>
1119 template<
typename _Tp>
1120 struct owner_less<weak_ptr<_Tp>>
1121 :
public _Sp_owner_less<weak_ptr<_Tp>, shared_ptr<_Tp>>
1125 class owner_less<void>
1127 template<
typename _Tp,
typename _Up>
1129 operator()(shared_ptr<_Tp>
const& __lhs,
1130 shared_ptr<_Up>
const& __rhs)
const 1131 {
return __lhs.owner_before(__rhs); }
1133 template<
typename _Tp,
typename _Up>
1135 operator()(shared_ptr<_Tp>
const& __lhs,
1136 weak_ptr<_Up>
const& __rhs)
const 1137 {
return __lhs.owner_before(__rhs); }
1139 template<
typename _Tp,
typename _Up>
1141 operator()(weak_ptr<_Tp>
const& __lhs,
1142 shared_ptr<_Up>
const& __rhs)
const 1143 {
return __lhs.owner_before(__rhs); }
1145 template<
typename _Tp,
typename _Up>
1147 operator()(weak_ptr<_Tp>
const& __lhs,
1148 weak_ptr<_Up>
const& __rhs)
const 1149 {
return __lhs.owner_before(__rhs); }
1151 typedef void is_transparent;
1155 template<
typename _Tp>
1157 atomic_is_lock_free(
const shared_ptr<_Tp>* __p)
1158 {
return std::atomic_is_lock_free<_Tp, __default_lock_policy>(__p); }
1160 template<
typename _Tp>
1161 shared_ptr<_Tp> atomic_load(
const shared_ptr<_Tp>* __p)
1162 {
return std::atomic_load<_Tp>(__p); }
1164 template<
typename _Tp>
1166 atomic_load_explicit(
const shared_ptr<_Tp>* __p,
memory_order __mo)
1167 {
return std::atomic_load_explicit<_Tp>(__p, __mo); }
1169 template<
typename _Tp>
1170 void atomic_store(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r)
1171 {
return std::atomic_store<_Tp>(__p, __r); }
1173 template<
typename _Tp>
1175 atomic_store_explicit(
const shared_ptr<_Tp>* __p,
1176 shared_ptr<_Tp> __r,
1178 {
return std::atomic_store_explicit<_Tp>(__p, __r, __mo); }
1180 template<
typename _Tp>
1181 void atomic_exchange(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r)
1182 {
return std::atomic_exchange<_Tp>(__p, __r); }
1184 template<
typename _Tp>
1186 atomic_exchange_explicit(
const shared_ptr<_Tp>* __p,
1187 shared_ptr<_Tp> __r,
1189 {
return std::atomic_exchange_explicit<_Tp>(__p, __r, __mo); }
1191 template<
typename _Tp>
1192 bool atomic_compare_exchange_weak(shared_ptr<_Tp>* __p,
1193 shared_ptr<_Tp>* __v,
1194 shared_ptr<_Tp> __w)
1195 {
return std::atomic_compare_exchange_weak<_Tp>(__p, __v, __w); }
1197 template<
typename _Tp>
1198 bool atomic_compare_exchange_strong(shared_ptr<_Tp>* __p,
1199 shared_ptr<_Tp>* __v,
1200 shared_ptr<_Tp> __w)
1201 {
return std::atomic_compare_exchange_strong<_Tp>(__p, __v, __w); }
1203 template<
typename _Tp>
1204 bool atomic_compare_exchange_weak_explicit(shared_ptr<_Tp>* __p,
1205 shared_ptr<_Tp>* __v,
1206 shared_ptr<_Tp> __w,
1209 {
return std::atomic_compare_exchange_weak_explicit<_Tp>(__p, __v, __w,
1213 template<
typename _Tp>
1214 bool atomic_compare_exchange_strong_explicit(shared_ptr<_Tp>* __p,
1215 shared_ptr<_Tp>* __v,
1216 shared_ptr<_Tp> __w,
1219 {
return std::atomic_compare_exchange_strong_explicit<_Tp>(__p, __v, __w,
1224 template<
typename _Tp>
1225 class enable_shared_from_this
1228 constexpr enable_shared_from_this() noexcept { }
1230 enable_shared_from_this(
const enable_shared_from_this&) noexcept { }
1232 enable_shared_from_this&
1233 operator=(
const enable_shared_from_this&) noexcept
1236 ~enable_shared_from_this() { }
1241 {
return shared_ptr<_Tp>(this->_M_weak_this); }
1243 shared_ptr<const _Tp>
1244 shared_from_this()
const 1245 {
return shared_ptr<const _Tp>(this->_M_weak_this); }
1248 weak_from_this() noexcept
1249 {
return _M_weak_this; }
1252 weak_from_this()
const noexcept
1253 {
return _M_weak_this; }
1256 template<
typename _Tp1>
1258 _M_weak_assign(_Tp1* __p,
const __shared_count<>& __n)
const noexcept
1259 { _M_weak_this._M_assign(__p, __n); }
1261 template<
typename _Tp1>
1263 __enable_shared_from_this_helper(
const __shared_count<>& __pn,
1264 const enable_shared_from_this* __pe,
1265 const _Tp1* __px) noexcept
1268 __pe->_M_weak_assign(const_cast<_Tp1*>(__px), __pn);
1271 mutable weak_ptr<_Tp> _M_weak_this;
1274 _GLIBCXX_END_NAMESPACE_VERSION
1278 _GLIBCXX_BEGIN_NAMESPACE_VERSION
1281 template<
typename _Tp>
1283 :
public __hash_base<size_t, experimental::shared_ptr<_Tp>>
1286 operator()(
const experimental::shared_ptr<_Tp>& __s)
const noexcept
1290 _GLIBCXX_END_NAMESPACE_VERSION
1293 #endif // __cplusplus <= 201103L 1295 #endif // _GLIBCXX_EXPERIMENTAL_SHARED_PTR_H memory_order
Enumeration for memory_order.
integral_constant< bool, false > false_type
The type used as a compile-time boolean with false value.
Template class basic_ostream.
constexpr _Tp && forward(typename std::remove_reference< _Tp >::type &__t) noexcept
Forward an lvalue.
One of the comparison functors.
integral_constant< bool, true > true_type
The type used as a compile-time boolean with true value.
shared_ptr< _Tp > allocate_shared(const _Alloc &__a, _Args &&... __args)
Create an object that is owned by a shared_ptr.
_Del * get_deleter(const __shared_ptr< _Tp, _Lp > &__p) noexcept
20.7.2.2.10 shared_ptr get_deleter
ISO C++ entities toplevel namespace is std.
void lock(_L1 &__l1, _L2 &__l2, _L3 &... __l3)
Generic lock.
Primary class template hash.
Partial specializations for pointer types.
A simple smart pointer providing strict ownership semantics.
A smart pointer with reference-counted copy semantics.