// -*- C++ -*- //===----------------------------------------------------------------------===// // // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. // See https://llvm.org/LICENSE.txt for license information. // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception // //===----------------------------------------------------------------------===// #ifndef _LIBCPP___MEMORY_SHARED_PTR_H #define _LIBCPP___MEMORY_SHARED_PTR_H #include <__compare/compare_three_way.h> #include <__compare/ordering.h> #include <__config> #include <__exception/exception.h> #include <__functional/binary_function.h> #include <__functional/operations.h> #include <__functional/reference_wrapper.h> #include <__fwd/ostream.h> #include <__iterator/access.h> #include <__memory/addressof.h> #include <__memory/allocation_guard.h> #include <__memory/allocator.h> #include <__memory/allocator_destructor.h> #include <__memory/allocator_traits.h> #include <__memory/auto_ptr.h> #include <__memory/compressed_pair.h> #include <__memory/construct_at.h> #include <__memory/pointer_traits.h> #include <__memory/uninitialized_algorithms.h> #include <__memory/unique_ptr.h> #include <__type_traits/add_lvalue_reference.h> #include <__type_traits/conditional.h> #include <__type_traits/conjunction.h> #include <__type_traits/disjunction.h> #include <__type_traits/is_array.h> #include <__type_traits/is_bounded_array.h> #include <__type_traits/is_constructible.h> #include <__type_traits/is_convertible.h> #include <__type_traits/is_reference.h> #include <__type_traits/is_unbounded_array.h> #include <__type_traits/nat.h> #include <__type_traits/negation.h> #include <__type_traits/remove_extent.h> #include <__type_traits/remove_reference.h> #include <__utility/declval.h> #include <__utility/forward.h> #include <__utility/move.h> #include <__utility/swap.h> #include <__verbose_abort> #include <cstddef> #include <new> #include <typeinfo> #if !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER) # include <__atomic/memory_order.h> #endif #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER) # pragma GCC system_header #endif _LIBCPP_PUSH_MACROS #include <__undef_macros> _LIBCPP_BEGIN_NAMESPACE_STD // NOTE: Relaxed and acq/rel atomics (for increment and decrement respectively) // should be sufficient for thread safety. // See https://llvm.org/PR22803 #if defined(__clang__) && __has_builtin(__atomic_add_fetch) && defined(__ATOMIC_RELAXED) && defined(__ATOMIC_ACQ_REL) #define _LIBCPP_HAS_BUILTIN_ATOMIC_SUPPORT #elif defined(_LIBCPP_COMPILER_GCC) #define _LIBCPP_HAS_BUILTIN_ATOMIC_SUPPORT #endif template <class _ValueType> inline _LIBCPP_HIDE_FROM_ABI _ValueType __libcpp_relaxed_load(_ValueType const* __value) { … } template <class _ValueType> inline _LIBCPP_HIDE_FROM_ABI _ValueType __libcpp_acquire_load(_ValueType const* __value) { … } template <class _Tp> inline _LIBCPP_HIDE_FROM_ABI _Tp __libcpp_atomic_refcount_increment(_Tp& __t) _NOEXCEPT { … } template <class _Tp> inline _LIBCPP_HIDE_FROM_ABI _Tp __libcpp_atomic_refcount_decrement(_Tp& __t) _NOEXCEPT { … } class _LIBCPP_EXPORTED_FROM_ABI bad_weak_ptr : public std::exception { … }; _LIBCPP_NORETURN inline _LIBCPP_HIDE_FROM_ABI void __throw_bad_weak_ptr() { … } template <class _Tp> class _LIBCPP_TEMPLATE_VIS weak_ptr; class _LIBCPP_EXPORTED_FROM_ABI __shared_count { … }; class _LIBCPP_EXPORTED_FROM_ABI __shared_weak_count : private __shared_count { … }; template <class _Tp, class _Dp, class _Alloc> class __shared_ptr_pointer : public __shared_weak_count { … }; #ifndef _LIBCPP_HAS_NO_RTTI template <class _Tp, class _Dp, class _Alloc> const void* __shared_ptr_pointer<_Tp, _Dp, _Alloc>::__get_deleter(const type_info& __t) const _NOEXCEPT { return __t == typeid(_Dp) ? std::addressof(__data_.first().second()) : nullptr; } #endif // _LIBCPP_HAS_NO_RTTI template <class _Tp, class _Dp, class _Alloc> void __shared_ptr_pointer<_Tp, _Dp, _Alloc>::__on_zero_shared() _NOEXCEPT { … } template <class _Tp, class _Dp, class _Alloc> void __shared_ptr_pointer<_Tp, _Dp, _Alloc>::__on_zero_shared_weak() _NOEXCEPT { … } // This tag is used to instantiate an allocator type. The various shared_ptr control blocks // detect that the allocator has been instantiated for this type and perform alternative // initialization/destruction based on that. struct __for_overwrite_tag { … }; template <class _Tp, class _Alloc> struct __shared_ptr_emplace : __shared_weak_count { … }; struct __shared_ptr_dummy_rebind_allocator_type; template <> class _LIBCPP_TEMPLATE_VIS allocator<__shared_ptr_dummy_rebind_allocator_type> { … }; template <class _Tp> class _LIBCPP_TEMPLATE_VIS enable_shared_from_this; // http://eel.is/c++draft/util.sharedptr#util.smartptr.shared.general-6 // A pointer type Y* is said to be compatible with a pointer type T* // when either Y* is convertible to T* or Y is U[N] and T is cv U[]. #if _LIBCPP_STD_VER >= 17 template <class _Yp, class _Tp> struct __bounded_convertible_to_unbounded : false_type { … }; __bounded_convertible_to_unbounded<_Up[_Np], _Tp>; template <class _Yp, class _Tp> struct __compatible_with : _Or< is_convertible<_Yp*, _Tp*>, __bounded_convertible_to_unbounded<_Yp, _Tp> > { … }; #else template <class _Yp, class _Tp> struct __compatible_with : is_convertible<_Yp*, _Tp*> {}; #endif // _LIBCPP_STD_VER >= 17 // Constructors that take raw pointers have a different set of "compatible" constraints // http://eel.is/c++draft/util.sharedptr#util.smartptr.shared.const-9.1 // - If T is an array type, then either T is U[N] and Y(*)[N] is convertible to T*, // or T is U[] and Y(*)[] is convertible to T*. // - If T is not an array type, then Y* is convertible to T*. #if _LIBCPP_STD_VER >= 17 template <class _Yp, class _Tp, class = void> struct __raw_pointer_compatible_with : _And< _Not<is_array<_Tp>>, is_convertible<_Yp*, _Tp*> > { … }; __raw_pointer_compatible_with<_Yp, _Up[_Np], __enable_if_t<is_convertible<_Yp (*)[_Np], _Up (*)[_Np]>::value>>; __raw_pointer_compatible_with<_Yp, _Up[], __enable_if_t<is_convertible<_Yp (*)[], _Up (*)[]>::value>>; #else template <class _Yp, class _Tp> struct __raw_pointer_compatible_with : is_convertible<_Yp*, _Tp*> {}; #endif // _LIBCPP_STD_VER >= 17 template <class _Ptr, class = void> struct __is_deletable : false_type { … }; __is_deletable<_Ptr, decltype(delete std::declval<_Ptr>())>; template <class _Ptr, class = void> struct __is_array_deletable : false_type { … }; __is_array_deletable<_Ptr, decltype(delete [] std::declval<_Ptr>())>; template <class _Dp, class _Pt, class = decltype(std::declval<_Dp>()(std::declval<_Pt>()))> true_type __well_formed_deleter_test(int); template <class, class> false_type __well_formed_deleter_test(...); template <class _Dp, class _Pt> struct __well_formed_deleter : decltype(std::__well_formed_deleter_test<_Dp, _Pt>(0)) { … }; template <class _Dp, class _Yp, class _Tp> struct __shared_ptr_deleter_ctor_reqs { … }; __shared_ptr_nullptr_deleter_ctor_reqs; #if defined(_LIBCPP_ABI_ENABLE_SHARED_PTR_TRIVIAL_ABI) #define _LIBCPP_SHARED_PTR_TRIVIAL_ABI … #else #define _LIBCPP_SHARED_PTR_TRIVIAL_ABI #endif template <class _Tp> class _LIBCPP_SHARED_PTR_TRIVIAL_ABI _LIBCPP_TEMPLATE_VIS shared_ptr { … }; #if _LIBCPP_STD_VER >= 17 template <class _Tp> shared_ptr(weak_ptr<_Tp>) -> shared_ptr<_Tp>; template <class _Tp, class _Dp> shared_ptr(unique_ptr<_Tp, _Dp>) -> shared_ptr<_Tp>; #endif // // std::allocate_shared and std::make_shared // template <class _Tp, class _Alloc, class... _Args, __enable_if_t<!is_array<_Tp>::value, int> = 0> _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> allocate_shared(const _Alloc& __a, _Args&&... __args) { … } template <class _Tp, class... _Args, __enable_if_t<!is_array<_Tp>::value, int> = 0> _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> make_shared(_Args&&... __args) { … } #if _LIBCPP_STD_VER >= 20 template <class _Tp, class _Alloc, __enable_if_t<!is_array<_Tp>::value, int> = 0> _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> allocate_shared_for_overwrite(const _Alloc& __a) { … } template <class _Tp, __enable_if_t<!is_array<_Tp>::value, int> = 0> _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> make_shared_for_overwrite() { … } #endif // _LIBCPP_STD_VER >= 20 #if _LIBCPP_STD_VER >= 17 template <size_t _Alignment> struct __sp_aligned_storage { … }; template <class _Tp, class _Alloc> struct __unbounded_array_control_block; __unbounded_array_control_block<_Tp[], _Alloc>; template <class _Array, class _Alloc, class... _Arg> _LIBCPP_HIDE_FROM_ABI shared_ptr<_Array> __allocate_shared_unbounded_array(const _Alloc& __a, size_t __n, _Arg&&... __arg) { … } template <class _Tp, class _Alloc> struct __bounded_array_control_block; __bounded_array_control_block<_Tp[_Count], _Alloc>; template <class _Array, class _Alloc, class... _Arg> _LIBCPP_HIDE_FROM_ABI shared_ptr<_Array> __allocate_shared_bounded_array(const _Alloc& __a, _Arg&&... __arg) { … } #endif // _LIBCPP_STD_VER >= 17 #if _LIBCPP_STD_VER >= 20 // bounded array variants template <class _Tp, class _Alloc, __enable_if_t<is_bounded_array<_Tp>::value, int> = 0> _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> allocate_shared(const _Alloc& __a) { … } template <class _Tp, class _Alloc, __enable_if_t<is_bounded_array<_Tp>::value, int> = 0> _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> allocate_shared(const _Alloc& __a, const remove_extent_t<_Tp>& __u) { … } template <class _Tp, class _Alloc, __enable_if_t<is_bounded_array<_Tp>::value, int> = 0> _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> allocate_shared_for_overwrite(const _Alloc& __a) { … } template <class _Tp, __enable_if_t<is_bounded_array<_Tp>::value, int> = 0> _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> make_shared() { … } template <class _Tp, __enable_if_t<is_bounded_array<_Tp>::value, int> = 0> _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> make_shared(const remove_extent_t<_Tp>& __u) { … } template <class _Tp, __enable_if_t<is_bounded_array<_Tp>::value, int> = 0> _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> make_shared_for_overwrite() { … } // unbounded array variants template <class _Tp, class _Alloc, __enable_if_t<is_unbounded_array<_Tp>::value, int> = 0> _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> allocate_shared(const _Alloc& __a, size_t __n) { … } template <class _Tp, class _Alloc, __enable_if_t<is_unbounded_array<_Tp>::value, int> = 0> _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> allocate_shared(const _Alloc& __a, size_t __n, const remove_extent_t<_Tp>& __u) { … } template <class _Tp, class _Alloc, __enable_if_t<is_unbounded_array<_Tp>::value, int> = 0> _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> allocate_shared_for_overwrite(const _Alloc& __a, size_t __n) { … } template <class _Tp, __enable_if_t<is_unbounded_array<_Tp>::value, int> = 0> _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> make_shared(size_t __n) { … } template <class _Tp, __enable_if_t<is_unbounded_array<_Tp>::value, int> = 0> _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> make_shared(size_t __n, const remove_extent_t<_Tp>& __u) { … } template <class _Tp, __enable_if_t<is_unbounded_array<_Tp>::value, int> = 0> _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> make_shared_for_overwrite(size_t __n) { … } #endif // _LIBCPP_STD_VER >= 20 template <class _Tp, class _Up> inline _LIBCPP_HIDE_FROM_ABI bool operator==(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT { … } #if _LIBCPP_STD_VER <= 17 template <class _Tp, class _Up> inline _LIBCPP_HIDE_FROM_ABI bool operator!=(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT { return !(__x == __y); } template <class _Tp, class _Up> inline _LIBCPP_HIDE_FROM_ABI bool operator<(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT { # if _LIBCPP_STD_VER <= 11 typedef typename common_type<_Tp*, _Up*>::type _Vp; return less<_Vp>()(__x.get(), __y.get()); # else return less<>()(__x.get(), __y.get()); # endif } template <class _Tp, class _Up> inline _LIBCPP_HIDE_FROM_ABI bool operator>(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT { return __y < __x; } template <class _Tp, class _Up> inline _LIBCPP_HIDE_FROM_ABI bool operator<=(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT { return !(__y < __x); } template <class _Tp, class _Up> inline _LIBCPP_HIDE_FROM_ABI bool operator>=(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT { return !(__x < __y); } #endif // _LIBCPP_STD_VER <= 17 #if _LIBCPP_STD_VER >= 20 template <class _Tp, class _Up> _LIBCPP_HIDE_FROM_ABI strong_ordering operator<=>(shared_ptr<_Tp> const& __x, shared_ptr<_Up> const& __y) noexcept { … } #endif template <class _Tp> inline _LIBCPP_HIDE_FROM_ABI bool operator==(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT { … } #if _LIBCPP_STD_VER <= 17 template <class _Tp> inline _LIBCPP_HIDE_FROM_ABI bool operator==(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT { return !__x; } template <class _Tp> inline _LIBCPP_HIDE_FROM_ABI bool operator!=(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT { return static_cast<bool>(__x); } template <class _Tp> inline _LIBCPP_HIDE_FROM_ABI bool operator!=(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT { return static_cast<bool>(__x); } template <class _Tp> inline _LIBCPP_HIDE_FROM_ABI bool operator<(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT { return less<typename shared_ptr<_Tp>::element_type*>()(__x.get(), nullptr); } template <class _Tp> inline _LIBCPP_HIDE_FROM_ABI bool operator<(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT { return less<typename shared_ptr<_Tp>::element_type*>()(nullptr, __x.get()); } template <class _Tp> inline _LIBCPP_HIDE_FROM_ABI bool operator>(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT { return nullptr < __x; } template <class _Tp> inline _LIBCPP_HIDE_FROM_ABI bool operator>(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT { return __x < nullptr; } template <class _Tp> inline _LIBCPP_HIDE_FROM_ABI bool operator<=(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT { return !(nullptr < __x); } template <class _Tp> inline _LIBCPP_HIDE_FROM_ABI bool operator<=(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT { return !(__x < nullptr); } template <class _Tp> inline _LIBCPP_HIDE_FROM_ABI bool operator>=(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT { return !(__x < nullptr); } template <class _Tp> inline _LIBCPP_HIDE_FROM_ABI bool operator>=(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT { return !(nullptr < __x); } #endif // _LIBCPP_STD_VER <= 17 #if _LIBCPP_STD_VER >= 20 template <class _Tp> _LIBCPP_HIDE_FROM_ABI strong_ordering operator<=>(shared_ptr<_Tp> const& __x, nullptr_t) noexcept { … } #endif template <class _Tp> inline _LIBCPP_HIDE_FROM_ABI void swap(shared_ptr<_Tp>& __x, shared_ptr<_Tp>& __y) _NOEXCEPT { … } template <class _Tp, class _Up> inline _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> static_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT { … } // LWG-2996 // We don't backport because it is an evolutionary change. #if _LIBCPP_STD_VER >= 20 template <class _Tp, class _Up> _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> static_pointer_cast(shared_ptr<_Up>&& __r) noexcept { … } #endif template <class _Tp, class _Up> inline _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> dynamic_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT { … } // LWG-2996 // We don't backport because it is an evolutionary change. #if _LIBCPP_STD_VER >= 20 template <class _Tp, class _Up> _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> dynamic_pointer_cast(shared_ptr<_Up>&& __r) noexcept { … } #endif template <class _Tp, class _Up> _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> const_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT { … } // LWG-2996 // We don't backport because it is an evolutionary change. #if _LIBCPP_STD_VER >= 20 template <class _Tp, class _Up> _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> const_pointer_cast(shared_ptr<_Up>&& __r) noexcept { … } #endif template <class _Tp, class _Up> _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> reinterpret_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT { … } // LWG-2996 // We don't backport because it is an evolutionary change. #if _LIBCPP_STD_VER >= 20 template <class _Tp, class _Up> _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> reinterpret_pointer_cast(shared_ptr<_Up>&& __r) noexcept { … } #endif #ifndef _LIBCPP_HAS_NO_RTTI template <class _Dp, class _Tp> inline _LIBCPP_HIDE_FROM_ABI _Dp* get_deleter(const shared_ptr<_Tp>& __p) _NOEXCEPT { return __p.template __get_deleter<_Dp>(); } #endif // _LIBCPP_HAS_NO_RTTI template <class _Tp> class _LIBCPP_SHARED_PTR_TRIVIAL_ABI _LIBCPP_TEMPLATE_VIS weak_ptr { … }; #if _LIBCPP_STD_VER >= 17 template <class _Tp> weak_ptr(shared_ptr<_Tp>) -> weak_ptr<_Tp>; #endif template <class _Tp> inline _LIBCPP_CONSTEXPR weak_ptr<_Tp>::weak_ptr() _NOEXCEPT : … { … } template <class _Tp> inline weak_ptr<_Tp>::weak_ptr(weak_ptr const& __r) _NOEXCEPT : … { … } template <class _Tp> template <class _Yp, __enable_if_t<__compatible_with<_Yp, _Tp>::value, int> > inline weak_ptr<_Tp>::weak_ptr(shared_ptr<_Yp> const& __r) _NOEXCEPT : __ptr_(__r.__ptr_), __cntrl_(__r.__cntrl_) { … } template <class _Tp> template <class _Yp, __enable_if_t<__compatible_with<_Yp, _Tp>::value, int> > inline weak_ptr<_Tp>::weak_ptr(weak_ptr<_Yp> const& __r) _NOEXCEPT : __ptr_(nullptr), __cntrl_(nullptr) { … } template <class _Tp> inline weak_ptr<_Tp>::weak_ptr(weak_ptr&& __r) _NOEXCEPT : … { … } template <class _Tp> template <class _Yp, __enable_if_t<__compatible_with<_Yp, _Tp>::value, int> > inline weak_ptr<_Tp>::weak_ptr(weak_ptr<_Yp>&& __r) _NOEXCEPT : __ptr_(nullptr), __cntrl_(nullptr) { … } template <class _Tp> weak_ptr<_Tp>::~weak_ptr() { … } template <class _Tp> inline weak_ptr<_Tp>& weak_ptr<_Tp>::operator=(weak_ptr const& __r) _NOEXCEPT { … } template <class _Tp> template <class _Yp, __enable_if_t<__compatible_with<_Yp, _Tp>::value, int> > inline weak_ptr<_Tp>& weak_ptr<_Tp>::operator=(weak_ptr<_Yp> const& __r) _NOEXCEPT { … } template <class _Tp> inline weak_ptr<_Tp>& weak_ptr<_Tp>::operator=(weak_ptr&& __r) _NOEXCEPT { … } template <class _Tp> template <class _Yp, __enable_if_t<__compatible_with<_Yp, _Tp>::value, int> > inline weak_ptr<_Tp>& weak_ptr<_Tp>::operator=(weak_ptr<_Yp>&& __r) _NOEXCEPT { … } template <class _Tp> template <class _Yp, __enable_if_t<__compatible_with<_Yp, _Tp>::value, int> > inline weak_ptr<_Tp>& weak_ptr<_Tp>::operator=(shared_ptr<_Yp> const& __r) _NOEXCEPT { … } template <class _Tp> inline void weak_ptr<_Tp>::swap(weak_ptr& __r) _NOEXCEPT { … } template <class _Tp> inline _LIBCPP_HIDE_FROM_ABI void swap(weak_ptr<_Tp>& __x, weak_ptr<_Tp>& __y) _NOEXCEPT { … } template <class _Tp> inline void weak_ptr<_Tp>::reset() _NOEXCEPT { … } template <class _Tp> shared_ptr<_Tp> weak_ptr<_Tp>::lock() const _NOEXCEPT { … } #if _LIBCPP_STD_VER >= 17 template <class _Tp = void> struct owner_less; #else template <class _Tp> struct owner_less; #endif owner_less<shared_ptr<_Tp>>; owner_less<weak_ptr<_Tp>>; #if _LIBCPP_STD_VER >= 17 template <> struct _LIBCPP_TEMPLATE_VIS owner_less<void> { … }; #endif template <class _Tp> class _LIBCPP_TEMPLATE_VIS enable_shared_from_this { … }; template <class _Tp> struct _LIBCPP_TEMPLATE_VIS hash; hash<shared_ptr<_Tp>>; template <class _CharT, class _Traits, class _Yp> inline _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>& operator<<(basic_ostream<_CharT, _Traits>& __os, shared_ptr<_Yp> const& __p); #if !defined(_LIBCPP_HAS_NO_THREADS) class _LIBCPP_EXPORTED_FROM_ABI __sp_mut { … }; _LIBCPP_EXPORTED_FROM_ABI __sp_mut& __get_sp_mut(const void*); template <class _Tp> inline _LIBCPP_HIDE_FROM_ABI bool atomic_is_lock_free(const shared_ptr<_Tp>*) { … } template <class _Tp> _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> atomic_load(const shared_ptr<_Tp>* __p) { … } template <class _Tp> inline _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> atomic_load_explicit(const shared_ptr<_Tp>* __p, memory_order) { … } template <class _Tp> _LIBCPP_HIDE_FROM_ABI void atomic_store(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r) { … } template <class _Tp> inline _LIBCPP_HIDE_FROM_ABI void atomic_store_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r, memory_order) { … } template <class _Tp> _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> atomic_exchange(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r) { … } template <class _Tp> inline _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> atomic_exchange_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r, memory_order) { … } template <class _Tp> _LIBCPP_HIDE_FROM_ABI bool atomic_compare_exchange_strong(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, shared_ptr<_Tp> __w) { … } template <class _Tp> inline _LIBCPP_HIDE_FROM_ABI bool atomic_compare_exchange_weak(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, shared_ptr<_Tp> __w) { … } template <class _Tp> inline _LIBCPP_HIDE_FROM_ABI bool atomic_compare_exchange_strong_explicit( shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, shared_ptr<_Tp> __w, memory_order, memory_order) { … } template <class _Tp> inline _LIBCPP_HIDE_FROM_ABI bool atomic_compare_exchange_weak_explicit( shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, shared_ptr<_Tp> __w, memory_order, memory_order) { … } #endif // !defined(_LIBCPP_HAS_NO_THREADS) _LIBCPP_END_NAMESPACE_STD _LIBCPP_POP_MACROS #endif // _LIBCPP___MEMORY_SHARED_PTR_H
Codebase Browser
chromium