1 // -*- C++ -*-
2 //===----------------------------------------------------------------------===//
3 //
4 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
5 // See https://llvm.org/LICENSE.txt for license information.
6 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
7 //
8 //===----------------------------------------------------------------------===//
9
10 #ifndef _LIBCPP___MEMORY_SHARED_PTR_H
11 #define _LIBCPP___MEMORY_SHARED_PTR_H
12
13 #include <__availability>
14 #include <__compare/compare_three_way.h>
15 #include <__compare/ordering.h>
16 #include <__config>
17 #include <__exception/exception.h>
18 #include <__functional/binary_function.h>
19 #include <__functional/operations.h>
20 #include <__functional/reference_wrapper.h>
21 #include <__fwd/ostream.h>
22 #include <__iterator/access.h>
23 #include <__memory/addressof.h>
24 #include <__memory/allocation_guard.h>
25 #include <__memory/allocator.h>
26 #include <__memory/allocator_destructor.h>
27 #include <__memory/allocator_traits.h>
28 #include <__memory/auto_ptr.h>
29 #include <__memory/compressed_pair.h>
30 #include <__memory/construct_at.h>
31 #include <__memory/pointer_traits.h>
32 #include <__memory/uninitialized_algorithms.h>
33 #include <__memory/unique_ptr.h>
34 #include <__type_traits/add_lvalue_reference.h>
35 #include <__type_traits/conditional.h>
36 #include <__type_traits/conjunction.h>
37 #include <__type_traits/disjunction.h>
38 #include <__type_traits/is_array.h>
39 #include <__type_traits/is_bounded_array.h>
40 #include <__type_traits/is_convertible.h>
41 #include <__type_traits/is_move_constructible.h>
42 #include <__type_traits/is_reference.h>
43 #include <__type_traits/is_unbounded_array.h>
44 #include <__type_traits/nat.h>
45 #include <__type_traits/negation.h>
46 #include <__type_traits/remove_extent.h>
47 #include <__type_traits/remove_reference.h>
48 #include <__utility/declval.h>
49 #include <__utility/forward.h>
50 #include <__utility/move.h>
51 #include <__utility/swap.h>
52 #include <__verbose_abort>
53 #include <cstddef>
54 #include <new>
55 #include <typeinfo>
56 #if !defined(_LIBCPP_HAS_NO_ATOMIC_HEADER)
57 # include <__atomic/memory_order.h>
58 #endif
59
60 #if !defined(_LIBCPP_HAS_NO_PRAGMA_SYSTEM_HEADER)
61 # pragma GCC system_header
62 #endif
63
64 _LIBCPP_PUSH_MACROS
65 #include <__undef_macros>
66
67 _LIBCPP_BEGIN_NAMESPACE_STD
68
69 // NOTE: Relaxed and acq/rel atomics (for increment and decrement respectively)
70 // should be sufficient for thread safety.
71 // See https://llvm.org/PR22803
72 #if defined(__clang__) && __has_builtin(__atomic_add_fetch) && defined(__ATOMIC_RELAXED) && defined(__ATOMIC_ACQ_REL)
73 # define _LIBCPP_HAS_BUILTIN_ATOMIC_SUPPORT
74 #elif defined(_LIBCPP_COMPILER_GCC)
75 # define _LIBCPP_HAS_BUILTIN_ATOMIC_SUPPORT
76 #endif
77
78 template <class _ValueType>
__libcpp_relaxed_load(_ValueType const * __value)79 inline _LIBCPP_HIDE_FROM_ABI _ValueType __libcpp_relaxed_load(_ValueType const* __value) {
80 #if !defined(_LIBCPP_HAS_NO_THREADS) && defined(__ATOMIC_RELAXED) && \
81 (__has_builtin(__atomic_load_n) || defined(_LIBCPP_COMPILER_GCC))
82 return __atomic_load_n(__value, __ATOMIC_RELAXED);
83 #else
84 return *__value;
85 #endif
86 }
87
88 template <class _ValueType>
__libcpp_acquire_load(_ValueType const * __value)89 inline _LIBCPP_HIDE_FROM_ABI _ValueType __libcpp_acquire_load(_ValueType const* __value) {
90 #if !defined(_LIBCPP_HAS_NO_THREADS) && defined(__ATOMIC_ACQUIRE) && \
91 (__has_builtin(__atomic_load_n) || defined(_LIBCPP_COMPILER_GCC))
92 return __atomic_load_n(__value, __ATOMIC_ACQUIRE);
93 #else
94 return *__value;
95 #endif
96 }
97
98 template <class _Tp>
__libcpp_atomic_refcount_increment(_Tp & __t)99 inline _LIBCPP_HIDE_FROM_ABI _Tp __libcpp_atomic_refcount_increment(_Tp& __t) _NOEXCEPT {
100 #if defined(_LIBCPP_HAS_BUILTIN_ATOMIC_SUPPORT) && !defined(_LIBCPP_HAS_NO_THREADS)
101 return __atomic_add_fetch(&__t, 1, __ATOMIC_RELAXED);
102 #else
103 return __t += 1;
104 #endif
105 }
106
107 template <class _Tp>
__libcpp_atomic_refcount_decrement(_Tp & __t)108 inline _LIBCPP_HIDE_FROM_ABI _Tp __libcpp_atomic_refcount_decrement(_Tp& __t) _NOEXCEPT {
109 #if defined(_LIBCPP_HAS_BUILTIN_ATOMIC_SUPPORT) && !defined(_LIBCPP_HAS_NO_THREADS)
110 return __atomic_add_fetch(&__t, -1, __ATOMIC_ACQ_REL);
111 #else
112 return __t -= 1;
113 #endif
114 }
115
116 class _LIBCPP_EXPORTED_FROM_ABI bad_weak_ptr : public std::exception {
117 public:
118 _LIBCPP_HIDE_FROM_ABI bad_weak_ptr() _NOEXCEPT = default;
119 _LIBCPP_HIDE_FROM_ABI bad_weak_ptr(const bad_weak_ptr&) _NOEXCEPT = default;
120 _LIBCPP_HIDE_FROM_ABI bad_weak_ptr& operator=(const bad_weak_ptr&) _NOEXCEPT = default;
121 ~bad_weak_ptr() _NOEXCEPT override;
122 const char* what() const _NOEXCEPT override;
123 };
124
__throw_bad_weak_ptr()125 _LIBCPP_NORETURN inline _LIBCPP_HIDE_FROM_ABI void __throw_bad_weak_ptr() {
126 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
127 throw bad_weak_ptr();
128 #else
129 _LIBCPP_VERBOSE_ABORT("bad_weak_ptr was thrown in -fno-exceptions mode");
130 #endif
131 }
132
133 template <class _Tp>
134 class _LIBCPP_TEMPLATE_VIS weak_ptr;
135
136 class _LIBCPP_EXPORTED_FROM_ABI __shared_count {
137 __shared_count(const __shared_count&);
138 __shared_count& operator=(const __shared_count&);
139
140 protected:
141 long __shared_owners_;
142 virtual ~__shared_count();
143
144 private:
145 virtual void __on_zero_shared() _NOEXCEPT = 0;
146
147 public:
__shared_owners_(__refs)148 _LIBCPP_HIDE_FROM_ABI explicit __shared_count(long __refs = 0) _NOEXCEPT : __shared_owners_(__refs) {}
149
150 #if defined(_LIBCPP_SHARED_PTR_DEFINE_LEGACY_INLINE_FUNCTIONS)
151 void __add_shared() noexcept;
152 bool __release_shared() noexcept;
153 #else
__add_shared()154 _LIBCPP_HIDE_FROM_ABI void __add_shared() _NOEXCEPT { __libcpp_atomic_refcount_increment(__shared_owners_); }
__release_shared()155 _LIBCPP_HIDE_FROM_ABI bool __release_shared() _NOEXCEPT {
156 if (__libcpp_atomic_refcount_decrement(__shared_owners_) == -1) {
157 __on_zero_shared();
158 return true;
159 }
160 return false;
161 }
162 #endif
use_count()163 _LIBCPP_HIDE_FROM_ABI long use_count() const _NOEXCEPT { return __libcpp_relaxed_load(&__shared_owners_) + 1; }
164 };
165
166 class _LIBCPP_EXPORTED_FROM_ABI __shared_weak_count : private __shared_count {
167 long __shared_weak_owners_;
168
169 public:
170 _LIBCPP_HIDE_FROM_ABI explicit __shared_weak_count(long __refs = 0) _NOEXCEPT
__shared_count(__refs)171 : __shared_count(__refs),
172 __shared_weak_owners_(__refs) {}
173
174 protected:
175 ~__shared_weak_count() override;
176
177 public:
178 #if defined(_LIBCPP_SHARED_PTR_DEFINE_LEGACY_INLINE_FUNCTIONS)
179 void __add_shared() noexcept;
180 void __add_weak() noexcept;
181 void __release_shared() noexcept;
182 #else
183 _LIBCPP_HIDE_FROM_ABI void __add_shared() _NOEXCEPT { __shared_count::__add_shared(); }
184 _LIBCPP_HIDE_FROM_ABI void __add_weak() _NOEXCEPT { __libcpp_atomic_refcount_increment(__shared_weak_owners_); }
185 _LIBCPP_HIDE_FROM_ABI void __release_shared() _NOEXCEPT {
186 if (__shared_count::__release_shared())
187 __release_weak();
188 }
189 #endif
190 void __release_weak() _NOEXCEPT;
use_count()191 _LIBCPP_HIDE_FROM_ABI long use_count() const _NOEXCEPT { return __shared_count::use_count(); }
192 __shared_weak_count* lock() _NOEXCEPT;
193
194 virtual const void* __get_deleter(const type_info&) const _NOEXCEPT;
195
196 private:
197 virtual void __on_zero_shared_weak() _NOEXCEPT = 0;
198 };
199
200 template <class _Tp, class _Dp, class _Alloc>
201 class __shared_ptr_pointer : public __shared_weak_count {
202 __compressed_pair<__compressed_pair<_Tp, _Dp>, _Alloc> __data_;
203
204 public:
__shared_ptr_pointer(_Tp __p,_Dp __d,_Alloc __a)205 _LIBCPP_HIDE_FROM_ABI __shared_ptr_pointer(_Tp __p, _Dp __d, _Alloc __a)
206 : __data_(__compressed_pair<_Tp, _Dp>(__p, std::move(__d)), std::move(__a)) {}
207
208 #ifndef _LIBCPP_HAS_NO_RTTI
209 _LIBCPP_HIDE_FROM_ABI_VIRTUAL const void* __get_deleter(const type_info&) const _NOEXCEPT override;
210 #endif
211
212 private:
213 _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __on_zero_shared() _NOEXCEPT override;
214 _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __on_zero_shared_weak() _NOEXCEPT override;
215 };
216
217 #ifndef _LIBCPP_HAS_NO_RTTI
218
219 template <class _Tp, class _Dp, class _Alloc>
__get_deleter(const type_info & __t)220 const void* __shared_ptr_pointer<_Tp, _Dp, _Alloc>::__get_deleter(const type_info& __t) const _NOEXCEPT {
221 return __t == typeid(_Dp) ? std::addressof(__data_.first().second()) : nullptr;
222 }
223
224 #endif // _LIBCPP_HAS_NO_RTTI
225
226 template <class _Tp, class _Dp, class _Alloc>
__on_zero_shared()227 void __shared_ptr_pointer<_Tp, _Dp, _Alloc>::__on_zero_shared() _NOEXCEPT {
228 __data_.first().second()(__data_.first().first());
229 __data_.first().second().~_Dp();
230 }
231
232 template <class _Tp, class _Dp, class _Alloc>
__on_zero_shared_weak()233 void __shared_ptr_pointer<_Tp, _Dp, _Alloc>::__on_zero_shared_weak() _NOEXCEPT {
234 typedef typename __allocator_traits_rebind<_Alloc, __shared_ptr_pointer>::type _Al;
235 typedef allocator_traits<_Al> _ATraits;
236 typedef pointer_traits<typename _ATraits::pointer> _PTraits;
237
238 _Al __a(__data_.second());
239 __data_.second().~_Alloc();
240 __a.deallocate(_PTraits::pointer_to(*this), 1);
241 }
242
243 // This tag is used to instantiate an allocator type. The various shared_ptr control blocks
244 // detect that the allocator has been instantiated for this type and perform alternative
245 // initialization/destruction based on that.
246 struct __for_overwrite_tag {};
247
248 template <class _Tp, class _Alloc>
249 struct __shared_ptr_emplace : __shared_weak_count {
250 template <class... _Args,
251 class _Allocator = _Alloc,
252 __enable_if_t<is_same<typename _Allocator::value_type, __for_overwrite_tag>::value, int> = 0>
__shared_ptr_emplace__shared_ptr_emplace253 _LIBCPP_HIDE_FROM_ABI explicit __shared_ptr_emplace(_Alloc __a, _Args&&...) : __storage_(std::move(__a)) {
254 static_assert(
255 sizeof...(_Args) == 0, "No argument should be provided to the control block when using _for_overwrite");
256 ::new ((void*)__get_elem()) _Tp;
257 }
258
259 template <class... _Args,
260 class _Allocator = _Alloc,
261 __enable_if_t<!is_same<typename _Allocator::value_type, __for_overwrite_tag>::value, int> = 0>
__shared_ptr_emplace__shared_ptr_emplace262 _LIBCPP_HIDE_FROM_ABI explicit __shared_ptr_emplace(_Alloc __a, _Args&&... __args) : __storage_(std::move(__a)) {
263 using _TpAlloc = typename __allocator_traits_rebind<_Alloc, _Tp>::type;
264 _TpAlloc __tmp(*__get_alloc());
265 allocator_traits<_TpAlloc>::construct(__tmp, __get_elem(), std::forward<_Args>(__args)...);
266 }
267
__get_alloc__shared_ptr_emplace268 _LIBCPP_HIDE_FROM_ABI _Alloc* __get_alloc() _NOEXCEPT { return __storage_.__get_alloc(); }
269
__get_elem__shared_ptr_emplace270 _LIBCPP_HIDE_FROM_ABI _Tp* __get_elem() _NOEXCEPT { return __storage_.__get_elem(); }
271
272 private:
273 template <class _Allocator = _Alloc,
274 __enable_if_t<is_same<typename _Allocator::value_type, __for_overwrite_tag>::value, int> = 0>
__on_zero_shared_impl__shared_ptr_emplace275 _LIBCPP_HIDE_FROM_ABI void __on_zero_shared_impl() _NOEXCEPT {
276 __get_elem()->~_Tp();
277 }
278
279 template <class _Allocator = _Alloc,
280 __enable_if_t<!is_same<typename _Allocator::value_type, __for_overwrite_tag>::value, int> = 0>
__on_zero_shared_impl__shared_ptr_emplace281 _LIBCPP_HIDE_FROM_ABI void __on_zero_shared_impl() _NOEXCEPT {
282 using _TpAlloc = typename __allocator_traits_rebind<_Allocator, _Tp>::type;
283 _TpAlloc __tmp(*__get_alloc());
284 allocator_traits<_TpAlloc>::destroy(__tmp, __get_elem());
285 }
286
__on_zero_shared__shared_ptr_emplace287 _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __on_zero_shared() _NOEXCEPT override { __on_zero_shared_impl(); }
288
__on_zero_shared_weak__shared_ptr_emplace289 _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __on_zero_shared_weak() _NOEXCEPT override {
290 using _ControlBlockAlloc = typename __allocator_traits_rebind<_Alloc, __shared_ptr_emplace>::type;
291 using _ControlBlockPointer = typename allocator_traits<_ControlBlockAlloc>::pointer;
292 _ControlBlockAlloc __tmp(*__get_alloc());
293 __storage_.~_Storage();
294 allocator_traits<_ControlBlockAlloc>::deallocate(__tmp, pointer_traits<_ControlBlockPointer>::pointer_to(*this), 1);
295 }
296
297 // This class implements the control block for non-array shared pointers created
298 // through `std::allocate_shared` and `std::make_shared`.
299 //
300 // In previous versions of the library, we used a compressed pair to store
301 // both the _Alloc and the _Tp. This implies using EBO, which is incompatible
302 // with Allocator construction for _Tp. To allow implementing P0674 in C++20,
303 // we now use a properly aligned char buffer while making sure that we maintain
304 // the same layout that we had when we used a compressed pair.
305 using _CompressedPair = __compressed_pair<_Alloc, _Tp>;
_ALIGNAS_TYPE__shared_ptr_emplace306 struct _ALIGNAS_TYPE(_CompressedPair) _Storage {
307 char __blob_[sizeof(_CompressedPair)];
308
309 _LIBCPP_HIDE_FROM_ABI explicit _Storage(_Alloc&& __a) { ::new ((void*)__get_alloc()) _Alloc(std::move(__a)); }
310 _LIBCPP_HIDE_FROM_ABI ~_Storage() { __get_alloc()->~_Alloc(); }
311 _LIBCPP_HIDE_FROM_ABI _Alloc* __get_alloc() _NOEXCEPT {
312 _CompressedPair* __as_pair = reinterpret_cast<_CompressedPair*>(__blob_);
313 typename _CompressedPair::_Base1* __first = _CompressedPair::__get_first_base(__as_pair);
314 _Alloc* __alloc = reinterpret_cast<_Alloc*>(__first);
315 return __alloc;
316 }
317 _LIBCPP_HIDE_FROM_ABI _LIBCPP_NO_CFI _Tp* __get_elem() _NOEXCEPT {
318 _CompressedPair* __as_pair = reinterpret_cast<_CompressedPair*>(__blob_);
319 typename _CompressedPair::_Base2* __second = _CompressedPair::__get_second_base(__as_pair);
320 _Tp* __elem = reinterpret_cast<_Tp*>(__second);
321 return __elem;
322 }
323 };
324
325 static_assert(_LIBCPP_ALIGNOF(_Storage) == _LIBCPP_ALIGNOF(_CompressedPair), "");
326 static_assert(sizeof(_Storage) == sizeof(_CompressedPair), "");
327 _Storage __storage_;
328 };
329
330 struct __shared_ptr_dummy_rebind_allocator_type;
331 template <>
332 class _LIBCPP_TEMPLATE_VIS allocator<__shared_ptr_dummy_rebind_allocator_type> {
333 public:
334 template <class _Other>
335 struct rebind {
336 typedef allocator<_Other> other;
337 };
338 };
339
340 template <class _Tp>
341 class _LIBCPP_TEMPLATE_VIS enable_shared_from_this;
342
343 // http://eel.is/c++draft/util.sharedptr#util.smartptr.shared.general-6
344 // A pointer type Y* is said to be compatible with a pointer type T*
345 // when either Y* is convertible to T* or Y is U[N] and T is cv U[].
346 #if _LIBCPP_STD_VER >= 17
347 template <class _Yp, class _Tp>
348 struct __bounded_convertible_to_unbounded : false_type {};
349
350 template <class _Up, std::size_t _Np, class _Tp>
351 struct __bounded_convertible_to_unbounded<_Up[_Np], _Tp> : is_same<__remove_cv_t<_Tp>, _Up[]> {};
352
353 template <class _Yp, class _Tp>
354 struct __compatible_with : _Or< is_convertible<_Yp*, _Tp*>, __bounded_convertible_to_unbounded<_Yp, _Tp> > {};
355 #else
356 template <class _Yp, class _Tp>
357 struct __compatible_with : is_convertible<_Yp*, _Tp*> {};
358 #endif // _LIBCPP_STD_VER >= 17
359
360 // Constructors that take raw pointers have a different set of "compatible" constraints
361 // http://eel.is/c++draft/util.sharedptr#util.smartptr.shared.const-9.1
362 // - If T is an array type, then either T is U[N] and Y(*)[N] is convertible to T*,
363 // or T is U[] and Y(*)[] is convertible to T*.
364 // - If T is not an array type, then Y* is convertible to T*.
365 #if _LIBCPP_STD_VER >= 17
366 template <class _Yp, class _Tp, class = void>
367 struct __raw_pointer_compatible_with : _And< _Not<is_array<_Tp>>, is_convertible<_Yp*, _Tp*> > {};
368
369 template <class _Yp, class _Up, std::size_t _Np>
370 struct __raw_pointer_compatible_with<_Yp, _Up[_Np], __enable_if_t< is_convertible<_Yp (*)[_Np], _Up (*)[_Np]>::value> >
371 : true_type {};
372
373 template <class _Yp, class _Up>
374 struct __raw_pointer_compatible_with<_Yp, _Up[], __enable_if_t< is_convertible<_Yp (*)[], _Up (*)[]>::value> >
375 : true_type {};
376
377 #else
378 template <class _Yp, class _Tp>
379 struct __raw_pointer_compatible_with : is_convertible<_Yp*, _Tp*> {};
380 #endif // _LIBCPP_STD_VER >= 17
381
382 template <class _Ptr, class = void>
383 struct __is_deletable : false_type {};
384 template <class _Ptr>
385 struct __is_deletable<_Ptr, decltype(delete std::declval<_Ptr>())> : true_type {};
386
387 template <class _Ptr, class = void>
388 struct __is_array_deletable : false_type {};
389 template <class _Ptr>
390 struct __is_array_deletable<_Ptr, decltype(delete[] std::declval<_Ptr>())> : true_type {};
391
392 template <class _Dp, class _Pt, class = decltype(std::declval<_Dp>()(std::declval<_Pt>()))>
393 true_type __well_formed_deleter_test(int);
394
395 template <class, class>
396 false_type __well_formed_deleter_test(...);
397
398 template <class _Dp, class _Pt>
399 struct __well_formed_deleter : decltype(std::__well_formed_deleter_test<_Dp, _Pt>(0)) {};
400
401 template <class _Dp, class _Yp, class _Tp>
402 struct __shared_ptr_deleter_ctor_reqs {
403 static const bool value = __raw_pointer_compatible_with<_Yp, _Tp>::value && is_move_constructible<_Dp>::value &&
404 __well_formed_deleter<_Dp, _Yp*>::value;
405 };
406
407 #if defined(_LIBCPP_ABI_ENABLE_SHARED_PTR_TRIVIAL_ABI)
408 # define _LIBCPP_SHARED_PTR_TRIVIAL_ABI __attribute__((__trivial_abi__))
409 #else
410 # define _LIBCPP_SHARED_PTR_TRIVIAL_ABI
411 #endif
412
413 template <class _Tp>
414 class _LIBCPP_SHARED_PTR_TRIVIAL_ABI _LIBCPP_TEMPLATE_VIS shared_ptr {
415 public:
416 #if _LIBCPP_STD_VER >= 17
417 typedef weak_ptr<_Tp> weak_type;
418 typedef remove_extent_t<_Tp> element_type;
419 #else
420 typedef _Tp element_type;
421 #endif
422
423 private:
424 element_type* __ptr_;
425 __shared_weak_count* __cntrl_;
426
427 public:
428 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR shared_ptr() _NOEXCEPT : __ptr_(nullptr), __cntrl_(nullptr) {}
429
430 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR shared_ptr(nullptr_t) _NOEXCEPT : __ptr_(nullptr), __cntrl_(nullptr) {}
431
432 template <class _Yp,
433 class = __enable_if_t< _And< __raw_pointer_compatible_with<_Yp, _Tp>
434 // In C++03 we get errors when trying to do SFINAE with the
435 // delete operator, so we always pretend that it's deletable.
436 // The same happens on GCC.
437 #if !defined(_LIBCPP_CXX03_LANG) && !defined(_LIBCPP_COMPILER_GCC)
438 ,
439 _If<is_array<_Tp>::value, __is_array_deletable<_Yp*>, __is_deletable<_Yp*> >
440 #endif
441 >::value > >
442 _LIBCPP_HIDE_FROM_ABI explicit shared_ptr(_Yp* __p) : __ptr_(__p) {
443 unique_ptr<_Yp> __hold(__p);
444 typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT;
445 typedef __shared_ptr_pointer<_Yp*, __shared_ptr_default_delete<_Tp, _Yp>, _AllocT> _CntrlBlk;
446 __cntrl_ = new _CntrlBlk(__p, __shared_ptr_default_delete<_Tp, _Yp>(), _AllocT());
447 __hold.release();
448 __enable_weak_this(__p, __p);
449 }
450
451 template <class _Yp, class _Dp, class = __enable_if_t<__shared_ptr_deleter_ctor_reqs<_Dp, _Yp, _Tp>::value> >
452 _LIBCPP_HIDE_FROM_ABI shared_ptr(_Yp* __p, _Dp __d) : __ptr_(__p) {
453 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
454 try {
455 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
456 typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT;
457 typedef __shared_ptr_pointer<_Yp*, _Dp, _AllocT> _CntrlBlk;
458 #ifndef _LIBCPP_CXX03_LANG
459 __cntrl_ = new _CntrlBlk(__p, std::move(__d), _AllocT());
460 #else
461 __cntrl_ = new _CntrlBlk(__p, __d, _AllocT());
462 #endif // not _LIBCPP_CXX03_LANG
463 __enable_weak_this(__p, __p);
464 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
465 } catch (...) {
466 __d(__p);
467 throw;
468 }
469 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
470 }
471
472 template <class _Yp,
473 class _Dp,
474 class _Alloc,
475 class = __enable_if_t<__shared_ptr_deleter_ctor_reqs<_Dp, _Yp, _Tp>::value> >
476 _LIBCPP_HIDE_FROM_ABI shared_ptr(_Yp* __p, _Dp __d, _Alloc __a) : __ptr_(__p) {
477 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
478 try {
479 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
480 typedef __shared_ptr_pointer<_Yp*, _Dp, _Alloc> _CntrlBlk;
481 typedef typename __allocator_traits_rebind<_Alloc, _CntrlBlk>::type _A2;
482 typedef __allocator_destructor<_A2> _D2;
483 _A2 __a2(__a);
484 unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1));
485 ::new ((void*)std::addressof(*__hold2.get()))
486 #ifndef _LIBCPP_CXX03_LANG
487 _CntrlBlk(__p, std::move(__d), __a);
488 #else
489 _CntrlBlk(__p, __d, __a);
490 #endif // not _LIBCPP_CXX03_LANG
491 __cntrl_ = std::addressof(*__hold2.release());
492 __enable_weak_this(__p, __p);
493 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
494 } catch (...) {
495 __d(__p);
496 throw;
497 }
498 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
499 }
500
501 template <class _Dp>
502 _LIBCPP_HIDE_FROM_ABI shared_ptr(nullptr_t __p, _Dp __d) : __ptr_(nullptr) {
503 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
504 try {
505 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
506 typedef typename __shared_ptr_default_allocator<_Tp>::type _AllocT;
507 typedef __shared_ptr_pointer<nullptr_t, _Dp, _AllocT> _CntrlBlk;
508 #ifndef _LIBCPP_CXX03_LANG
509 __cntrl_ = new _CntrlBlk(__p, std::move(__d), _AllocT());
510 #else
511 __cntrl_ = new _CntrlBlk(__p, __d, _AllocT());
512 #endif // not _LIBCPP_CXX03_LANG
513 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
514 } catch (...) {
515 __d(__p);
516 throw;
517 }
518 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
519 }
520
521 template <class _Dp, class _Alloc>
522 _LIBCPP_HIDE_FROM_ABI shared_ptr(nullptr_t __p, _Dp __d, _Alloc __a) : __ptr_(nullptr) {
523 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
524 try {
525 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
526 typedef __shared_ptr_pointer<nullptr_t, _Dp, _Alloc> _CntrlBlk;
527 typedef typename __allocator_traits_rebind<_Alloc, _CntrlBlk>::type _A2;
528 typedef __allocator_destructor<_A2> _D2;
529 _A2 __a2(__a);
530 unique_ptr<_CntrlBlk, _D2> __hold2(__a2.allocate(1), _D2(__a2, 1));
531 ::new ((void*)std::addressof(*__hold2.get()))
532 #ifndef _LIBCPP_CXX03_LANG
533 _CntrlBlk(__p, std::move(__d), __a);
534 #else
535 _CntrlBlk(__p, __d, __a);
536 #endif // not _LIBCPP_CXX03_LANG
537 __cntrl_ = std::addressof(*__hold2.release());
538 #ifndef _LIBCPP_HAS_NO_EXCEPTIONS
539 } catch (...) {
540 __d(__p);
541 throw;
542 }
543 #endif // _LIBCPP_HAS_NO_EXCEPTIONS
544 }
545
546 template <class _Yp>
547 _LIBCPP_HIDE_FROM_ABI shared_ptr(const shared_ptr<_Yp>& __r, element_type* __p) _NOEXCEPT
548 : __ptr_(__p),
549 __cntrl_(__r.__cntrl_) {
550 if (__cntrl_)
551 __cntrl_->__add_shared();
552 }
553
554 // LWG-2996
555 // We don't backport because it is an evolutionary change.
556 #if _LIBCPP_STD_VER >= 20
557 template <class _Yp>
558 _LIBCPP_HIDE_FROM_ABI shared_ptr(shared_ptr<_Yp>&& __r, element_type* __p) noexcept
559 : __ptr_(__p), __cntrl_(__r.__cntrl_) {
560 __r.__ptr_ = nullptr;
561 __r.__cntrl_ = nullptr;
562 }
563 #endif
564
565 _LIBCPP_HIDE_FROM_ABI shared_ptr(const shared_ptr& __r) _NOEXCEPT : __ptr_(__r.__ptr_), __cntrl_(__r.__cntrl_) {
566 if (__cntrl_)
567 __cntrl_->__add_shared();
568 }
569
570 template <class _Yp, class = __enable_if_t<__compatible_with<_Yp, _Tp>::value> >
571 _LIBCPP_HIDE_FROM_ABI shared_ptr(const shared_ptr<_Yp>& __r) _NOEXCEPT : __ptr_(__r.__ptr_), __cntrl_(__r.__cntrl_) {
572 if (__cntrl_)
573 __cntrl_->__add_shared();
574 }
575
576 _LIBCPP_HIDE_FROM_ABI shared_ptr(shared_ptr&& __r) _NOEXCEPT : __ptr_(__r.__ptr_), __cntrl_(__r.__cntrl_) {
577 __r.__ptr_ = nullptr;
578 __r.__cntrl_ = nullptr;
579 }
580
581 template <class _Yp, class = __enable_if_t<__compatible_with<_Yp, _Tp>::value> >
582 _LIBCPP_HIDE_FROM_ABI shared_ptr(shared_ptr<_Yp>&& __r) _NOEXCEPT : __ptr_(__r.__ptr_), __cntrl_(__r.__cntrl_) {
583 __r.__ptr_ = nullptr;
584 __r.__cntrl_ = nullptr;
585 }
586
587 template <class _Yp, class = __enable_if_t<__compatible_with<_Yp, _Tp>::value> >
588 _LIBCPP_HIDE_FROM_ABI explicit shared_ptr(const weak_ptr<_Yp>& __r)
589 : __ptr_(__r.__ptr_), __cntrl_(__r.__cntrl_ ? __r.__cntrl_->lock() : __r.__cntrl_) {
590 if (__cntrl_ == nullptr)
591 __throw_bad_weak_ptr();
592 }
593
594 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
595 template <class _Yp, class = __enable_if_t<is_convertible<_Yp*, element_type*>::value> >
596 _LIBCPP_HIDE_FROM_ABI shared_ptr(auto_ptr<_Yp>&& __r) : __ptr_(__r.get()) {
597 typedef __shared_ptr_pointer<_Yp*, default_delete<_Yp>, allocator<_Yp> > _CntrlBlk;
598 __cntrl_ = new _CntrlBlk(__r.get(), default_delete<_Yp>(), allocator<_Yp>());
599 __enable_weak_this(__r.get(), __r.get());
600 __r.release();
601 }
602 #endif
603
604 template <class _Yp,
605 class _Dp,
606 class = __enable_if_t< !is_lvalue_reference<_Dp>::value && __compatible_with<_Yp, _Tp>::value &&
607 is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value > >
608 _LIBCPP_HIDE_FROM_ABI shared_ptr(unique_ptr<_Yp, _Dp>&& __r) : __ptr_(__r.get()) {
609 #if _LIBCPP_STD_VER >= 14
610 if (__ptr_ == nullptr)
611 __cntrl_ = nullptr;
612 else
613 #endif
614 {
615 typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT;
616 typedef __shared_ptr_pointer<typename unique_ptr<_Yp, _Dp>::pointer, _Dp, _AllocT> _CntrlBlk;
617 __cntrl_ = new _CntrlBlk(__r.get(), std::move(__r.get_deleter()), _AllocT());
618 __enable_weak_this(__r.get(), __r.get());
619 }
620 __r.release();
621 }
622
623 template <class _Yp,
624 class _Dp,
625 class = void,
626 class = __enable_if_t< is_lvalue_reference<_Dp>::value && __compatible_with<_Yp, _Tp>::value &&
627 is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*>::value > >
628 _LIBCPP_HIDE_FROM_ABI shared_ptr(unique_ptr<_Yp, _Dp>&& __r) : __ptr_(__r.get()) {
629 #if _LIBCPP_STD_VER >= 14
630 if (__ptr_ == nullptr)
631 __cntrl_ = nullptr;
632 else
633 #endif
634 {
635 typedef typename __shared_ptr_default_allocator<_Yp>::type _AllocT;
636 typedef __shared_ptr_pointer<typename unique_ptr<_Yp, _Dp>::pointer,
637 reference_wrapper<__libcpp_remove_reference_t<_Dp> >,
638 _AllocT>
639 _CntrlBlk;
640 __cntrl_ = new _CntrlBlk(__r.get(), std::ref(__r.get_deleter()), _AllocT());
641 __enable_weak_this(__r.get(), __r.get());
642 }
643 __r.release();
644 }
645
646 _LIBCPP_HIDE_FROM_ABI ~shared_ptr() {
647 if (__cntrl_)
648 __cntrl_->__release_shared();
649 }
650
651 _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp>& operator=(const shared_ptr& __r) _NOEXCEPT {
652 shared_ptr(__r).swap(*this);
653 return *this;
654 }
655
656 template <class _Yp, class = __enable_if_t<__compatible_with<_Yp, _Tp>::value> >
657 _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp>& operator=(const shared_ptr<_Yp>& __r) _NOEXCEPT {
658 shared_ptr(__r).swap(*this);
659 return *this;
660 }
661
662 _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp>& operator=(shared_ptr&& __r) _NOEXCEPT {
663 shared_ptr(std::move(__r)).swap(*this);
664 return *this;
665 }
666
667 template <class _Yp, class = __enable_if_t<__compatible_with<_Yp, _Tp>::value> >
668 _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp>& operator=(shared_ptr<_Yp>&& __r) {
669 shared_ptr(std::move(__r)).swap(*this);
670 return *this;
671 }
672
673 #if _LIBCPP_STD_VER <= 14 || defined(_LIBCPP_ENABLE_CXX17_REMOVED_AUTO_PTR)
674 template <class _Yp,
675 class = __enable_if_t< !is_array<_Yp>::value &&
676 is_convertible<_Yp*, typename shared_ptr<_Tp>::element_type*>::value > >
677 _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp>& operator=(auto_ptr<_Yp>&& __r) {
678 shared_ptr(std::move(__r)).swap(*this);
679 return *this;
680 }
681 #endif
682
683 template <
684 class _Yp,
685 class _Dp,
686 class = __enable_if_t<_And< __compatible_with<_Yp, _Tp>,
687 is_convertible<typename unique_ptr<_Yp, _Dp>::pointer, element_type*> >::value> >
688 _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp>& operator=(unique_ptr<_Yp, _Dp>&& __r) {
689 shared_ptr(std::move(__r)).swap(*this);
690 return *this;
691 }
692
693 _LIBCPP_HIDE_FROM_ABI void swap(shared_ptr& __r) _NOEXCEPT {
694 std::swap(__ptr_, __r.__ptr_);
695 std::swap(__cntrl_, __r.__cntrl_);
696 }
697
698 _LIBCPP_HIDE_FROM_ABI void reset() _NOEXCEPT { shared_ptr().swap(*this); }
699
700 template <class _Yp, class = __enable_if_t< __raw_pointer_compatible_with<_Yp, _Tp>::value > >
701 _LIBCPP_HIDE_FROM_ABI void reset(_Yp* __p) {
702 shared_ptr(__p).swap(*this);
703 }
704
705 template <class _Yp, class _Dp, class = __enable_if_t< __shared_ptr_deleter_ctor_reqs<_Dp, _Yp, _Tp>::value> >
706 _LIBCPP_HIDE_FROM_ABI void reset(_Yp* __p, _Dp __d) {
707 shared_ptr(__p, __d).swap(*this);
708 }
709
710 template <class _Yp,
711 class _Dp,
712 class _Alloc,
713 class = __enable_if_t< __shared_ptr_deleter_ctor_reqs<_Dp, _Yp, _Tp>::value> >
714 _LIBCPP_HIDE_FROM_ABI void reset(_Yp* __p, _Dp __d, _Alloc __a) {
715 shared_ptr(__p, __d, __a).swap(*this);
716 }
717
718 _LIBCPP_HIDE_FROM_ABI element_type* get() const _NOEXCEPT { return __ptr_; }
719
720 _LIBCPP_HIDE_FROM_ABI __add_lvalue_reference_t<element_type> operator*() const _NOEXCEPT { return *__ptr_; }
721
722 _LIBCPP_HIDE_FROM_ABI element_type* operator->() const _NOEXCEPT {
723 static_assert(!is_array<_Tp>::value, "std::shared_ptr<T>::operator-> is only valid when T is not an array type.");
724 return __ptr_;
725 }
726
727 _LIBCPP_HIDE_FROM_ABI long use_count() const _NOEXCEPT { return __cntrl_ ? __cntrl_->use_count() : 0; }
728
729 #if _LIBCPP_STD_VER < 20 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_SHARED_PTR_UNIQUE)
730 _LIBCPP_DEPRECATED_IN_CXX17 _LIBCPP_HIDE_FROM_ABI bool unique() const _NOEXCEPT { return use_count() == 1; }
731 #endif
732
733 _LIBCPP_HIDE_FROM_ABI explicit operator bool() const _NOEXCEPT { return get() != nullptr; }
734
735 template <class _Up>
736 _LIBCPP_HIDE_FROM_ABI bool owner_before(shared_ptr<_Up> const& __p) const _NOEXCEPT {
737 return __cntrl_ < __p.__cntrl_;
738 }
739
740 template <class _Up>
741 _LIBCPP_HIDE_FROM_ABI bool owner_before(weak_ptr<_Up> const& __p) const _NOEXCEPT {
742 return __cntrl_ < __p.__cntrl_;
743 }
744
745 _LIBCPP_HIDE_FROM_ABI bool __owner_equivalent(const shared_ptr& __p) const { return __cntrl_ == __p.__cntrl_; }
746
747 #if _LIBCPP_STD_VER >= 17
748 _LIBCPP_HIDE_FROM_ABI __add_lvalue_reference_t<element_type> operator[](ptrdiff_t __i) const {
749 static_assert(is_array<_Tp>::value, "std::shared_ptr<T>::operator[] is only valid when T is an array type.");
750 return __ptr_[__i];
751 }
752 #endif
753
754 #ifndef _LIBCPP_HAS_NO_RTTI
755 template <class _Dp>
756 _LIBCPP_HIDE_FROM_ABI _Dp* __get_deleter() const _NOEXCEPT {
757 return static_cast<_Dp*>(__cntrl_ ? const_cast<void*>(__cntrl_->__get_deleter(typeid(_Dp))) : nullptr);
758 }
759 #endif // _LIBCPP_HAS_NO_RTTI
760
761 template <class _Yp, class _CntrlBlk>
762 _LIBCPP_HIDE_FROM_ABI static shared_ptr<_Tp> __create_with_control_block(_Yp* __p, _CntrlBlk* __cntrl) _NOEXCEPT {
763 shared_ptr<_Tp> __r;
764 __r.__ptr_ = __p;
765 __r.__cntrl_ = __cntrl;
766 __r.__enable_weak_this(__r.__ptr_, __r.__ptr_);
767 return __r;
768 }
769
770 private:
771 template <class _Yp, bool = is_function<_Yp>::value>
772 struct __shared_ptr_default_allocator {
773 typedef allocator<_Yp> type;
774 };
775
776 template <class _Yp>
777 struct __shared_ptr_default_allocator<_Yp, true> {
778 typedef allocator<__shared_ptr_dummy_rebind_allocator_type> type;
779 };
780
781 template <class _Yp,
782 class _OrigPtr,
783 class = __enable_if_t< is_convertible<_OrigPtr*, const enable_shared_from_this<_Yp>*>::value > >
784 _LIBCPP_HIDE_FROM_ABI void __enable_weak_this(const enable_shared_from_this<_Yp>* __e, _OrigPtr* __ptr) _NOEXCEPT {
785 typedef __remove_cv_t<_Yp> _RawYp;
786 if (__e && __e->__weak_this_.expired()) {
787 __e->__weak_this_ = shared_ptr<_RawYp>(*this, const_cast<_RawYp*>(static_cast<const _Yp*>(__ptr)));
788 }
789 }
790
791 _LIBCPP_HIDE_FROM_ABI void __enable_weak_this(...) _NOEXCEPT {}
792
793 template <class, class _Yp>
794 struct __shared_ptr_default_delete : default_delete<_Yp> {};
795
796 template <class _Yp, class _Un, size_t _Sz>
797 struct __shared_ptr_default_delete<_Yp[_Sz], _Un> : default_delete<_Yp[]> {};
798
799 template <class _Yp, class _Un>
800 struct __shared_ptr_default_delete<_Yp[], _Un> : default_delete<_Yp[]> {};
801
802 template <class _Up>
803 friend class _LIBCPP_TEMPLATE_VIS shared_ptr;
804 template <class _Up>
805 friend class _LIBCPP_TEMPLATE_VIS weak_ptr;
806 };
807
808 #if _LIBCPP_STD_VER >= 17
809 template <class _Tp>
810 shared_ptr(weak_ptr<_Tp>) -> shared_ptr<_Tp>;
811 template <class _Tp, class _Dp>
812 shared_ptr(unique_ptr<_Tp, _Dp>) -> shared_ptr<_Tp>;
813 #endif
814
815 //
816 // std::allocate_shared and std::make_shared
817 //
818 template <class _Tp, class _Alloc, class... _Args, class = __enable_if_t<!is_array<_Tp>::value> >
819 _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> allocate_shared(const _Alloc& __a, _Args&&... __args) {
820 using _ControlBlock = __shared_ptr_emplace<_Tp, _Alloc>;
821 using _ControlBlockAllocator = typename __allocator_traits_rebind<_Alloc, _ControlBlock>::type;
822 __allocation_guard<_ControlBlockAllocator> __guard(__a, 1);
823 ::new ((void*)std::addressof(*__guard.__get())) _ControlBlock(__a, std::forward<_Args>(__args)...);
824 auto __control_block = __guard.__release_ptr();
825 return shared_ptr<_Tp>::__create_with_control_block(
826 (*__control_block).__get_elem(), std::addressof(*__control_block));
827 }
828
829 template <class _Tp, class... _Args, class = __enable_if_t<!is_array<_Tp>::value> >
830 _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> make_shared(_Args&&... __args) {
831 return std::allocate_shared<_Tp>(allocator<_Tp>(), std::forward<_Args>(__args)...);
832 }
833
834 #if _LIBCPP_STD_VER >= 20
835
836 template <class _Tp, class _Alloc, __enable_if_t<!is_array<_Tp>::value, int> = 0>
837 _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> allocate_shared_for_overwrite(const _Alloc& __a) {
838 using _ForOverwriteAllocator = __allocator_traits_rebind_t<_Alloc, __for_overwrite_tag>;
839 _ForOverwriteAllocator __alloc(__a);
840 return std::allocate_shared<_Tp>(__alloc);
841 }
842
843 template <class _Tp, __enable_if_t<!is_array<_Tp>::value, int> = 0>
844 _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> make_shared_for_overwrite() {
845 return std::allocate_shared_for_overwrite<_Tp>(allocator<_Tp>());
846 }
847
848 #endif // _LIBCPP_STD_VER >= 20
849
850 #if _LIBCPP_STD_VER >= 17
851
852 template <size_t _Alignment>
853 struct __sp_aligned_storage {
854 alignas(_Alignment) char __storage[_Alignment];
855 };
856
857 template <class _Tp, class _Alloc>
858 struct __unbounded_array_control_block;
859
860 template <class _Tp, class _Alloc>
861 struct __unbounded_array_control_block<_Tp[], _Alloc> : __shared_weak_count {
862 _LIBCPP_HIDE_FROM_ABI constexpr _Tp* __get_data() noexcept { return __data_; }
863
864 _LIBCPP_HIDE_FROM_ABI explicit __unbounded_array_control_block(
865 _Alloc const& __alloc, size_t __count, _Tp const& __arg)
866 : __alloc_(__alloc), __count_(__count) {
867 std::__uninitialized_allocator_fill_n_multidimensional(__alloc_, std::begin(__data_), __count_, __arg);
868 }
869
870 _LIBCPP_HIDE_FROM_ABI explicit __unbounded_array_control_block(_Alloc const& __alloc, size_t __count)
871 : __alloc_(__alloc), __count_(__count) {
872 # if _LIBCPP_STD_VER >= 20
873 if constexpr (is_same_v<typename _Alloc::value_type, __for_overwrite_tag>) {
874 // We are purposefully not using an allocator-aware default construction because the spec says so.
875 // There's currently no way of expressing default initialization in an allocator-aware manner anyway.
876 std::uninitialized_default_construct_n(std::begin(__data_), __count_);
877 } else {
878 std::__uninitialized_allocator_value_construct_n_multidimensional(__alloc_, std::begin(__data_), __count_);
879 }
880 # else
881 std::__uninitialized_allocator_value_construct_n_multidimensional(__alloc_, std::begin(__data_), __count_);
882 # endif
883 }
884
885 // Returns the number of bytes required to store a control block followed by the given number
886 // of elements of _Tp, with the whole storage being aligned to a multiple of _Tp's alignment.
887 _LIBCPP_HIDE_FROM_ABI static constexpr size_t __bytes_for(size_t __elements) {
888 // When there's 0 elements, the control block alone is enough since it holds one element.
889 // Otherwise, we allocate one fewer element than requested because the control block already
890 // holds one. Also, we use the bitwise formula below to ensure that we allocate enough bytes
891 // for the whole allocation to be a multiple of _Tp's alignment. That formula is taken from [1].
892 //
893 // [1]: https://en.wikipedia.org/wiki/Data_structure_alignment#Computing_padding
894 size_t __bytes = __elements == 0 ? sizeof(__unbounded_array_control_block)
895 : (__elements - 1) * sizeof(_Tp) + sizeof(__unbounded_array_control_block);
896 constexpr size_t __align = alignof(_Tp);
897 return (__bytes + __align - 1) & ~(__align - 1);
898 }
899
900 _LIBCPP_HIDE_FROM_ABI_VIRTUAL
901 ~__unbounded_array_control_block() override {
902 } // can't be `= default` because of the sometimes-non-trivial union member __data_
903
904 private:
905 _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __on_zero_shared() _NOEXCEPT override {
906 # if _LIBCPP_STD_VER >= 20
907 if constexpr (is_same_v<typename _Alloc::value_type, __for_overwrite_tag>) {
908 std::__reverse_destroy(__data_, __data_ + __count_);
909 } else {
910 __allocator_traits_rebind_t<_Alloc, _Tp> __value_alloc(__alloc_);
911 std::__allocator_destroy_multidimensional(__value_alloc, __data_, __data_ + __count_);
912 }
913 # else
914 __allocator_traits_rebind_t<_Alloc, _Tp> __value_alloc(__alloc_);
915 std::__allocator_destroy_multidimensional(__value_alloc, __data_, __data_ + __count_);
916 # endif
917 }
918
919 _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __on_zero_shared_weak() _NOEXCEPT override {
920 using _AlignedStorage = __sp_aligned_storage<alignof(__unbounded_array_control_block)>;
921 using _StorageAlloc = __allocator_traits_rebind_t<_Alloc, _AlignedStorage>;
922 using _PointerTraits = pointer_traits<typename allocator_traits<_StorageAlloc>::pointer>;
923
924 _StorageAlloc __tmp(__alloc_);
925 __alloc_.~_Alloc();
926 size_t __size = __unbounded_array_control_block::__bytes_for(__count_);
927 _AlignedStorage* __storage = reinterpret_cast<_AlignedStorage*>(this);
928 allocator_traits<_StorageAlloc>::deallocate(
929 __tmp, _PointerTraits::pointer_to(*__storage), __size / sizeof(_AlignedStorage));
930 }
931
932 _LIBCPP_NO_UNIQUE_ADDRESS _Alloc __alloc_;
933 size_t __count_;
934 union {
935 _Tp __data_[1];
936 };
937 };
938
939 template <class _Array, class _Alloc, class... _Arg>
940 _LIBCPP_HIDE_FROM_ABI shared_ptr<_Array>
941 __allocate_shared_unbounded_array(const _Alloc& __a, size_t __n, _Arg&&... __arg) {
942 static_assert(__libcpp_is_unbounded_array<_Array>::value);
943 // We compute the number of bytes necessary to hold the control block and the
944 // array elements. Then, we allocate an array of properly-aligned dummy structs
945 // large enough to hold the control block and array. This allows shifting the
946 // burden of aligning memory properly from us to the allocator.
947 using _ControlBlock = __unbounded_array_control_block<_Array, _Alloc>;
948 using _AlignedStorage = __sp_aligned_storage<alignof(_ControlBlock)>;
949 using _StorageAlloc = __allocator_traits_rebind_t<_Alloc, _AlignedStorage>;
950 __allocation_guard<_StorageAlloc> __guard(__a, _ControlBlock::__bytes_for(__n) / sizeof(_AlignedStorage));
951 _ControlBlock* __control_block = reinterpret_cast<_ControlBlock*>(std::addressof(*__guard.__get()));
952 std::__construct_at(__control_block, __a, __n, std::forward<_Arg>(__arg)...);
953 __guard.__release_ptr();
954 return shared_ptr<_Array>::__create_with_control_block(__control_block->__get_data(), __control_block);
955 }
956
957 template <class _Tp, class _Alloc>
958 struct __bounded_array_control_block;
959
960 template <class _Tp, size_t _Count, class _Alloc>
961 struct __bounded_array_control_block<_Tp[_Count], _Alloc> : __shared_weak_count {
962 _LIBCPP_HIDE_FROM_ABI constexpr _Tp* __get_data() noexcept { return __data_; }
963
964 _LIBCPP_HIDE_FROM_ABI explicit __bounded_array_control_block(_Alloc const& __alloc, _Tp const& __arg)
965 : __alloc_(__alloc) {
966 std::__uninitialized_allocator_fill_n_multidimensional(__alloc_, std::addressof(__data_[0]), _Count, __arg);
967 }
968
969 _LIBCPP_HIDE_FROM_ABI explicit __bounded_array_control_block(_Alloc const& __alloc) : __alloc_(__alloc) {
970 # if _LIBCPP_STD_VER >= 20
971 if constexpr (is_same_v<typename _Alloc::value_type, __for_overwrite_tag>) {
972 // We are purposefully not using an allocator-aware default construction because the spec says so.
973 // There's currently no way of expressing default initialization in an allocator-aware manner anyway.
974 std::uninitialized_default_construct_n(std::addressof(__data_[0]), _Count);
975 } else {
976 std::__uninitialized_allocator_value_construct_n_multidimensional(__alloc_, std::addressof(__data_[0]), _Count);
977 }
978 # else
979 std::__uninitialized_allocator_value_construct_n_multidimensional(__alloc_, std::addressof(__data_[0]), _Count);
980 # endif
981 }
982
983 _LIBCPP_HIDE_FROM_ABI_VIRTUAL
984 ~__bounded_array_control_block() override {
985 } // can't be `= default` because of the sometimes-non-trivial union member __data_
986
987 private:
988 _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __on_zero_shared() _NOEXCEPT override {
989 # if _LIBCPP_STD_VER >= 20
990 if constexpr (is_same_v<typename _Alloc::value_type, __for_overwrite_tag>) {
991 std::__reverse_destroy(__data_, __data_ + _Count);
992 } else {
993 __allocator_traits_rebind_t<_Alloc, _Tp> __value_alloc(__alloc_);
994 std::__allocator_destroy_multidimensional(__value_alloc, __data_, __data_ + _Count);
995 }
996 # else
997 __allocator_traits_rebind_t<_Alloc, _Tp> __value_alloc(__alloc_);
998 std::__allocator_destroy_multidimensional(__value_alloc, __data_, __data_ + _Count);
999 # endif
1000 }
1001
1002 _LIBCPP_HIDE_FROM_ABI_VIRTUAL void __on_zero_shared_weak() _NOEXCEPT override {
1003 using _ControlBlockAlloc = __allocator_traits_rebind_t<_Alloc, __bounded_array_control_block>;
1004 using _PointerTraits = pointer_traits<typename allocator_traits<_ControlBlockAlloc>::pointer>;
1005
1006 _ControlBlockAlloc __tmp(__alloc_);
1007 __alloc_.~_Alloc();
1008 allocator_traits<_ControlBlockAlloc>::deallocate(__tmp, _PointerTraits::pointer_to(*this), 1);
1009 }
1010
1011 _LIBCPP_NO_UNIQUE_ADDRESS _Alloc __alloc_;
1012 union {
1013 _Tp __data_[_Count];
1014 };
1015 };
1016
1017 template <class _Array, class _Alloc, class... _Arg>
1018 _LIBCPP_HIDE_FROM_ABI shared_ptr<_Array> __allocate_shared_bounded_array(const _Alloc& __a, _Arg&&... __arg) {
1019 static_assert(__libcpp_is_bounded_array<_Array>::value);
1020 using _ControlBlock = __bounded_array_control_block<_Array, _Alloc>;
1021 using _ControlBlockAlloc = __allocator_traits_rebind_t<_Alloc, _ControlBlock>;
1022
1023 __allocation_guard<_ControlBlockAlloc> __guard(__a, 1);
1024 _ControlBlock* __control_block = reinterpret_cast<_ControlBlock*>(std::addressof(*__guard.__get()));
1025 std::__construct_at(__control_block, __a, std::forward<_Arg>(__arg)...);
1026 __guard.__release_ptr();
1027 return shared_ptr<_Array>::__create_with_control_block(__control_block->__get_data(), __control_block);
1028 }
1029
1030 #endif // _LIBCPP_STD_VER >= 17
1031
1032 #if _LIBCPP_STD_VER >= 20
1033
1034 // bounded array variants
1035 template <class _Tp, class _Alloc, class = __enable_if_t<is_bounded_array<_Tp>::value>>
1036 _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> allocate_shared(const _Alloc& __a) {
1037 return std::__allocate_shared_bounded_array<_Tp>(__a);
1038 }
1039
1040 template <class _Tp, class _Alloc, class = __enable_if_t<is_bounded_array<_Tp>::value>>
1041 _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> allocate_shared(const _Alloc& __a, const remove_extent_t<_Tp>& __u) {
1042 return std::__allocate_shared_bounded_array<_Tp>(__a, __u);
1043 }
1044
1045 template <class _Tp, class _Alloc, __enable_if_t<is_bounded_array<_Tp>::value, int> = 0>
1046 _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> allocate_shared_for_overwrite(const _Alloc& __a) {
1047 using _ForOverwriteAllocator = __allocator_traits_rebind_t<_Alloc, __for_overwrite_tag>;
1048 _ForOverwriteAllocator __alloc(__a);
1049 return std::__allocate_shared_bounded_array<_Tp>(__alloc);
1050 }
1051
1052 template <class _Tp, class = __enable_if_t<is_bounded_array<_Tp>::value>>
1053 _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> make_shared() {
1054 return std::__allocate_shared_bounded_array<_Tp>(allocator<_Tp>());
1055 }
1056
1057 template <class _Tp, class = __enable_if_t<is_bounded_array<_Tp>::value>>
1058 _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> make_shared(const remove_extent_t<_Tp>& __u) {
1059 return std::__allocate_shared_bounded_array<_Tp>(allocator<_Tp>(), __u);
1060 }
1061
1062 template <class _Tp, __enable_if_t<is_bounded_array<_Tp>::value, int> = 0>
1063 _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> make_shared_for_overwrite() {
1064 return std::__allocate_shared_bounded_array<_Tp>(allocator<__for_overwrite_tag>());
1065 }
1066
1067 // unbounded array variants
1068 template <class _Tp, class _Alloc, class = __enable_if_t<is_unbounded_array<_Tp>::value>>
1069 _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> allocate_shared(const _Alloc& __a, size_t __n) {
1070 return std::__allocate_shared_unbounded_array<_Tp>(__a, __n);
1071 }
1072
1073 template <class _Tp, class _Alloc, class = __enable_if_t<is_unbounded_array<_Tp>::value>>
1074 _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> allocate_shared(const _Alloc& __a, size_t __n, const remove_extent_t<_Tp>& __u) {
1075 return std::__allocate_shared_unbounded_array<_Tp>(__a, __n, __u);
1076 }
1077
1078 template <class _Tp, class _Alloc, __enable_if_t<is_unbounded_array<_Tp>::value, int> = 0>
1079 _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> allocate_shared_for_overwrite(const _Alloc& __a, size_t __n) {
1080 using _ForOverwriteAllocator = __allocator_traits_rebind_t<_Alloc, __for_overwrite_tag>;
1081 _ForOverwriteAllocator __alloc(__a);
1082 return std::__allocate_shared_unbounded_array<_Tp>(__alloc, __n);
1083 }
1084
1085 template <class _Tp, class = __enable_if_t<is_unbounded_array<_Tp>::value>>
1086 _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> make_shared(size_t __n) {
1087 return std::__allocate_shared_unbounded_array<_Tp>(allocator<_Tp>(), __n);
1088 }
1089
1090 template <class _Tp, class = __enable_if_t<is_unbounded_array<_Tp>::value>>
1091 _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> make_shared(size_t __n, const remove_extent_t<_Tp>& __u) {
1092 return std::__allocate_shared_unbounded_array<_Tp>(allocator<_Tp>(), __n, __u);
1093 }
1094
1095 template <class _Tp, __enable_if_t<is_unbounded_array<_Tp>::value, int> = 0>
1096 _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> make_shared_for_overwrite(size_t __n) {
1097 return std::__allocate_shared_unbounded_array<_Tp>(allocator<__for_overwrite_tag>(), __n);
1098 }
1099
1100 #endif // _LIBCPP_STD_VER >= 20
1101
1102 template <class _Tp, class _Up>
1103 inline _LIBCPP_HIDE_FROM_ABI bool operator==(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT {
1104 return __x.get() == __y.get();
1105 }
1106
1107 #if _LIBCPP_STD_VER <= 17
1108
1109 template <class _Tp, class _Up>
1110 inline _LIBCPP_HIDE_FROM_ABI bool operator!=(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT {
1111 return !(__x == __y);
1112 }
1113
1114 template <class _Tp, class _Up>
1115 inline _LIBCPP_HIDE_FROM_ABI bool operator<(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT {
1116 # if _LIBCPP_STD_VER <= 11
1117 typedef typename common_type<_Tp*, _Up*>::type _Vp;
1118 return less<_Vp>()(__x.get(), __y.get());
1119 # else
1120 return less<>()(__x.get(), __y.get());
1121 # endif
1122 }
1123
1124 template <class _Tp, class _Up>
1125 inline _LIBCPP_HIDE_FROM_ABI bool operator>(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT {
1126 return __y < __x;
1127 }
1128
1129 template <class _Tp, class _Up>
1130 inline _LIBCPP_HIDE_FROM_ABI bool operator<=(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT {
1131 return !(__y < __x);
1132 }
1133
1134 template <class _Tp, class _Up>
1135 inline _LIBCPP_HIDE_FROM_ABI bool operator>=(const shared_ptr<_Tp>& __x, const shared_ptr<_Up>& __y) _NOEXCEPT {
1136 return !(__x < __y);
1137 }
1138
1139 #endif // _LIBCPP_STD_VER <= 17
1140
1141 #if _LIBCPP_STD_VER >= 20
1142 template <class _Tp, class _Up>
1143 _LIBCPP_HIDE_FROM_ABI strong_ordering operator<=>(shared_ptr<_Tp> const& __x, shared_ptr<_Up> const& __y) noexcept {
1144 return compare_three_way()(__x.get(), __y.get());
1145 }
1146 #endif
1147
1148 template <class _Tp>
1149 inline _LIBCPP_HIDE_FROM_ABI bool operator==(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT {
1150 return !__x;
1151 }
1152
1153 #if _LIBCPP_STD_VER <= 17
1154
1155 template <class _Tp>
1156 inline _LIBCPP_HIDE_FROM_ABI bool operator==(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT {
1157 return !__x;
1158 }
1159
1160 template <class _Tp>
1161 inline _LIBCPP_HIDE_FROM_ABI bool operator!=(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT {
1162 return static_cast<bool>(__x);
1163 }
1164
1165 template <class _Tp>
1166 inline _LIBCPP_HIDE_FROM_ABI bool operator!=(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT {
1167 return static_cast<bool>(__x);
1168 }
1169
1170 template <class _Tp>
1171 inline _LIBCPP_HIDE_FROM_ABI bool operator<(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT {
1172 return less<typename shared_ptr<_Tp>::element_type*>()(__x.get(), nullptr);
1173 }
1174
1175 template <class _Tp>
1176 inline _LIBCPP_HIDE_FROM_ABI bool operator<(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT {
1177 return less<typename shared_ptr<_Tp>::element_type*>()(nullptr, __x.get());
1178 }
1179
1180 template <class _Tp>
1181 inline _LIBCPP_HIDE_FROM_ABI bool operator>(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT {
1182 return nullptr < __x;
1183 }
1184
1185 template <class _Tp>
1186 inline _LIBCPP_HIDE_FROM_ABI bool operator>(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT {
1187 return __x < nullptr;
1188 }
1189
1190 template <class _Tp>
1191 inline _LIBCPP_HIDE_FROM_ABI bool operator<=(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT {
1192 return !(nullptr < __x);
1193 }
1194
1195 template <class _Tp>
1196 inline _LIBCPP_HIDE_FROM_ABI bool operator<=(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT {
1197 return !(__x < nullptr);
1198 }
1199
1200 template <class _Tp>
1201 inline _LIBCPP_HIDE_FROM_ABI bool operator>=(const shared_ptr<_Tp>& __x, nullptr_t) _NOEXCEPT {
1202 return !(__x < nullptr);
1203 }
1204
1205 template <class _Tp>
1206 inline _LIBCPP_HIDE_FROM_ABI bool operator>=(nullptr_t, const shared_ptr<_Tp>& __x) _NOEXCEPT {
1207 return !(nullptr < __x);
1208 }
1209
1210 #endif // _LIBCPP_STD_VER <= 17
1211
1212 #if _LIBCPP_STD_VER >= 20
1213 template <class _Tp>
1214 _LIBCPP_HIDE_FROM_ABI strong_ordering operator<=>(shared_ptr<_Tp> const& __x, nullptr_t) noexcept {
1215 return compare_three_way()(__x.get(), static_cast<typename shared_ptr<_Tp>::element_type*>(nullptr));
1216 }
1217 #endif
1218
1219 template <class _Tp>
1220 inline _LIBCPP_HIDE_FROM_ABI void swap(shared_ptr<_Tp>& __x, shared_ptr<_Tp>& __y) _NOEXCEPT {
1221 __x.swap(__y);
1222 }
1223
1224 template <class _Tp, class _Up>
1225 inline _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> static_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT {
1226 return shared_ptr<_Tp>(__r, static_cast< typename shared_ptr<_Tp>::element_type*>(__r.get()));
1227 }
1228
1229 // LWG-2996
1230 // We don't backport because it is an evolutionary change.
1231 #if _LIBCPP_STD_VER >= 20
1232 template <class _Tp, class _Up>
1233 _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> static_pointer_cast(shared_ptr<_Up>&& __r) noexcept {
1234 return shared_ptr<_Tp>(std::move(__r), static_cast<typename shared_ptr<_Tp>::element_type*>(__r.get()));
1235 }
1236 #endif
1237
1238 template <class _Tp, class _Up>
1239 inline _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> dynamic_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT {
1240 typedef typename shared_ptr<_Tp>::element_type _ET;
1241 _ET* __p = dynamic_cast<_ET*>(__r.get());
1242 return __p ? shared_ptr<_Tp>(__r, __p) : shared_ptr<_Tp>();
1243 }
1244
1245 // LWG-2996
1246 // We don't backport because it is an evolutionary change.
1247 #if _LIBCPP_STD_VER >= 20
1248 template <class _Tp, class _Up>
1249 _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> dynamic_pointer_cast(shared_ptr<_Up>&& __r) noexcept {
1250 auto* __p = dynamic_cast<typename shared_ptr<_Tp>::element_type*>(__r.get());
1251 return __p ? shared_ptr<_Tp>(std::move(__r), __p) : shared_ptr<_Tp>();
1252 }
1253 #endif
1254
1255 template <class _Tp, class _Up>
1256 _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> const_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT {
1257 typedef typename shared_ptr<_Tp>::element_type _RTp;
1258 return shared_ptr<_Tp>(__r, const_cast<_RTp*>(__r.get()));
1259 }
1260
1261 // LWG-2996
1262 // We don't backport because it is an evolutionary change.
1263 #if _LIBCPP_STD_VER >= 20
1264 template <class _Tp, class _Up>
1265 _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> const_pointer_cast(shared_ptr<_Up>&& __r) noexcept {
1266 return shared_ptr<_Tp>(std::move(__r), const_cast<typename shared_ptr<_Tp>::element_type*>(__r.get()));
1267 }
1268 #endif
1269
1270 template <class _Tp, class _Up>
1271 _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> reinterpret_pointer_cast(const shared_ptr<_Up>& __r) _NOEXCEPT {
1272 return shared_ptr<_Tp>(__r, reinterpret_cast< typename shared_ptr<_Tp>::element_type*>(__r.get()));
1273 }
1274
1275 // LWG-2996
1276 // We don't backport because it is an evolutionary change.
1277 #if _LIBCPP_STD_VER >= 20
1278 template <class _Tp, class _Up>
1279 _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> reinterpret_pointer_cast(shared_ptr<_Up>&& __r) noexcept {
1280 return shared_ptr<_Tp>(std::move(__r), reinterpret_cast<typename shared_ptr<_Tp>::element_type*>(__r.get()));
1281 }
1282 #endif
1283
1284 #ifndef _LIBCPP_HAS_NO_RTTI
1285
1286 template <class _Dp, class _Tp>
1287 inline _LIBCPP_HIDE_FROM_ABI _Dp* get_deleter(const shared_ptr<_Tp>& __p) _NOEXCEPT {
1288 return __p.template __get_deleter<_Dp>();
1289 }
1290
1291 #endif // _LIBCPP_HAS_NO_RTTI
1292
1293 template <class _Tp>
1294 class _LIBCPP_SHARED_PTR_TRIVIAL_ABI _LIBCPP_TEMPLATE_VIS weak_ptr {
1295 public:
1296 #if _LIBCPP_STD_VER >= 17
1297 typedef remove_extent_t<_Tp> element_type;
1298 #else
1299 typedef _Tp element_type;
1300 #endif
1301
1302 private:
1303 element_type* __ptr_;
1304 __shared_weak_count* __cntrl_;
1305
1306 public:
1307 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR weak_ptr() _NOEXCEPT;
1308
1309 template <class _Yp, __enable_if_t<__compatible_with<_Yp, _Tp>::value, int> = 0>
1310 _LIBCPP_HIDE_FROM_ABI weak_ptr(shared_ptr<_Yp> const& __r) _NOEXCEPT;
1311
1312 _LIBCPP_HIDE_FROM_ABI weak_ptr(weak_ptr const& __r) _NOEXCEPT;
1313
1314 template <class _Yp, __enable_if_t<__compatible_with<_Yp, _Tp>::value, int> = 0>
1315 _LIBCPP_HIDE_FROM_ABI weak_ptr(weak_ptr<_Yp> const& __r) _NOEXCEPT;
1316
1317 _LIBCPP_HIDE_FROM_ABI weak_ptr(weak_ptr&& __r) _NOEXCEPT;
1318
1319 template <class _Yp, __enable_if_t<__compatible_with<_Yp, _Tp>::value, int> = 0>
1320 _LIBCPP_HIDE_FROM_ABI weak_ptr(weak_ptr<_Yp>&& __r) _NOEXCEPT;
1321
1322 _LIBCPP_HIDE_FROM_ABI ~weak_ptr();
1323
1324 _LIBCPP_HIDE_FROM_ABI weak_ptr& operator=(weak_ptr const& __r) _NOEXCEPT;
1325 template <class _Yp, __enable_if_t<__compatible_with<_Yp, _Tp>::value, int> = 0>
1326 _LIBCPP_HIDE_FROM_ABI weak_ptr& operator=(weak_ptr<_Yp> const& __r) _NOEXCEPT;
1327
1328 _LIBCPP_HIDE_FROM_ABI weak_ptr& operator=(weak_ptr&& __r) _NOEXCEPT;
1329 template <class _Yp, __enable_if_t<__compatible_with<_Yp, _Tp>::value, int> = 0>
1330 _LIBCPP_HIDE_FROM_ABI weak_ptr& operator=(weak_ptr<_Yp>&& __r) _NOEXCEPT;
1331
1332 template <class _Yp, __enable_if_t<__compatible_with<_Yp, _Tp>::value, int> = 0>
1333 _LIBCPP_HIDE_FROM_ABI weak_ptr& operator=(shared_ptr<_Yp> const& __r) _NOEXCEPT;
1334
1335 _LIBCPP_HIDE_FROM_ABI void swap(weak_ptr& __r) _NOEXCEPT;
1336 _LIBCPP_HIDE_FROM_ABI void reset() _NOEXCEPT;
1337
1338 _LIBCPP_HIDE_FROM_ABI long use_count() const _NOEXCEPT { return __cntrl_ ? __cntrl_->use_count() : 0; }
1339 _LIBCPP_HIDE_FROM_ABI bool expired() const _NOEXCEPT { return __cntrl_ == nullptr || __cntrl_->use_count() == 0; }
1340 _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> lock() const _NOEXCEPT;
1341 template <class _Up>
1342 _LIBCPP_HIDE_FROM_ABI bool owner_before(const shared_ptr<_Up>& __r) const _NOEXCEPT {
1343 return __cntrl_ < __r.__cntrl_;
1344 }
1345 template <class _Up>
1346 _LIBCPP_HIDE_FROM_ABI bool owner_before(const weak_ptr<_Up>& __r) const _NOEXCEPT {
1347 return __cntrl_ < __r.__cntrl_;
1348 }
1349
1350 template <class _Up>
1351 friend class _LIBCPP_TEMPLATE_VIS weak_ptr;
1352 template <class _Up>
1353 friend class _LIBCPP_TEMPLATE_VIS shared_ptr;
1354 };
1355
1356 #if _LIBCPP_STD_VER >= 17
1357 template <class _Tp>
1358 weak_ptr(shared_ptr<_Tp>) -> weak_ptr<_Tp>;
1359 #endif
1360
1361 template <class _Tp>
1362 inline _LIBCPP_CONSTEXPR weak_ptr<_Tp>::weak_ptr() _NOEXCEPT : __ptr_(nullptr), __cntrl_(nullptr) {}
1363
1364 template <class _Tp>
1365 inline weak_ptr<_Tp>::weak_ptr(weak_ptr const& __r) _NOEXCEPT : __ptr_(__r.__ptr_), __cntrl_(__r.__cntrl_) {
1366 if (__cntrl_)
1367 __cntrl_->__add_weak();
1368 }
1369
1370 template <class _Tp>
1371 template <class _Yp, __enable_if_t<__compatible_with<_Yp, _Tp>::value, int> >
1372 inline weak_ptr<_Tp>::weak_ptr(shared_ptr<_Yp> const& __r) _NOEXCEPT : __ptr_(__r.__ptr_), __cntrl_(__r.__cntrl_) {
1373 if (__cntrl_)
1374 __cntrl_->__add_weak();
1375 }
1376
1377 template <class _Tp>
1378 template <class _Yp, __enable_if_t<__compatible_with<_Yp, _Tp>::value, int> >
1379 inline weak_ptr<_Tp>::weak_ptr(weak_ptr<_Yp> const& __r) _NOEXCEPT : __ptr_(nullptr), __cntrl_(nullptr) {
1380 shared_ptr<_Yp> __s = __r.lock();
1381 *this = weak_ptr<_Tp>(__s);
1382 }
1383
1384 template <class _Tp>
1385 inline weak_ptr<_Tp>::weak_ptr(weak_ptr&& __r) _NOEXCEPT : __ptr_(__r.__ptr_), __cntrl_(__r.__cntrl_) {
1386 __r.__ptr_ = nullptr;
1387 __r.__cntrl_ = nullptr;
1388 }
1389
1390 template <class _Tp>
1391 template <class _Yp, __enable_if_t<__compatible_with<_Yp, _Tp>::value, int> >
1392 inline weak_ptr<_Tp>::weak_ptr(weak_ptr<_Yp>&& __r) _NOEXCEPT : __ptr_(nullptr), __cntrl_(nullptr) {
1393 shared_ptr<_Yp> __s = __r.lock();
1394 *this = weak_ptr<_Tp>(__s);
1395 __r.reset();
1396 }
1397
1398 template <class _Tp>
1399 weak_ptr<_Tp>::~weak_ptr() {
1400 if (__cntrl_)
1401 __cntrl_->__release_weak();
1402 }
1403
1404 template <class _Tp>
1405 inline weak_ptr<_Tp>& weak_ptr<_Tp>::operator=(weak_ptr const& __r) _NOEXCEPT {
1406 weak_ptr(__r).swap(*this);
1407 return *this;
1408 }
1409
1410 template <class _Tp>
1411 template <class _Yp, __enable_if_t<__compatible_with<_Yp, _Tp>::value, int> >
1412 inline weak_ptr<_Tp>& weak_ptr<_Tp>::operator=(weak_ptr<_Yp> const& __r) _NOEXCEPT {
1413 weak_ptr(__r).swap(*this);
1414 return *this;
1415 }
1416
1417 template <class _Tp>
1418 inline weak_ptr<_Tp>& weak_ptr<_Tp>::operator=(weak_ptr&& __r) _NOEXCEPT {
1419 weak_ptr(std::move(__r)).swap(*this);
1420 return *this;
1421 }
1422
1423 template <class _Tp>
1424 template <class _Yp, __enable_if_t<__compatible_with<_Yp, _Tp>::value, int> >
1425 inline weak_ptr<_Tp>& weak_ptr<_Tp>::operator=(weak_ptr<_Yp>&& __r) _NOEXCEPT {
1426 weak_ptr(std::move(__r)).swap(*this);
1427 return *this;
1428 }
1429
1430 template <class _Tp>
1431 template <class _Yp, __enable_if_t<__compatible_with<_Yp, _Tp>::value, int> >
1432 inline weak_ptr<_Tp>& weak_ptr<_Tp>::operator=(shared_ptr<_Yp> const& __r) _NOEXCEPT {
1433 weak_ptr(__r).swap(*this);
1434 return *this;
1435 }
1436
1437 template <class _Tp>
1438 inline void weak_ptr<_Tp>::swap(weak_ptr& __r) _NOEXCEPT {
1439 std::swap(__ptr_, __r.__ptr_);
1440 std::swap(__cntrl_, __r.__cntrl_);
1441 }
1442
1443 template <class _Tp>
1444 inline _LIBCPP_HIDE_FROM_ABI void swap(weak_ptr<_Tp>& __x, weak_ptr<_Tp>& __y) _NOEXCEPT {
1445 __x.swap(__y);
1446 }
1447
1448 template <class _Tp>
1449 inline void weak_ptr<_Tp>::reset() _NOEXCEPT {
1450 weak_ptr().swap(*this);
1451 }
1452
1453 template <class _Tp>
1454 shared_ptr<_Tp> weak_ptr<_Tp>::lock() const _NOEXCEPT {
1455 shared_ptr<_Tp> __r;
1456 __r.__cntrl_ = __cntrl_ ? __cntrl_->lock() : __cntrl_;
1457 if (__r.__cntrl_)
1458 __r.__ptr_ = __ptr_;
1459 return __r;
1460 }
1461
1462 #if _LIBCPP_STD_VER >= 17
1463 template <class _Tp = void>
1464 struct owner_less;
1465 #else
1466 template <class _Tp>
1467 struct owner_less;
1468 #endif
1469
1470 template <class _Tp>
1471 struct _LIBCPP_TEMPLATE_VIS owner_less<shared_ptr<_Tp> > : __binary_function<shared_ptr<_Tp>, shared_ptr<_Tp>, bool> {
1472 _LIBCPP_HIDE_FROM_ABI bool operator()(shared_ptr<_Tp> const& __x, shared_ptr<_Tp> const& __y) const _NOEXCEPT {
1473 return __x.owner_before(__y);
1474 }
1475 _LIBCPP_HIDE_FROM_ABI bool operator()(shared_ptr<_Tp> const& __x, weak_ptr<_Tp> const& __y) const _NOEXCEPT {
1476 return __x.owner_before(__y);
1477 }
1478 _LIBCPP_HIDE_FROM_ABI bool operator()(weak_ptr<_Tp> const& __x, shared_ptr<_Tp> const& __y) const _NOEXCEPT {
1479 return __x.owner_before(__y);
1480 }
1481 };
1482
1483 template <class _Tp>
1484 struct _LIBCPP_TEMPLATE_VIS owner_less<weak_ptr<_Tp> > : __binary_function<weak_ptr<_Tp>, weak_ptr<_Tp>, bool> {
1485 _LIBCPP_HIDE_FROM_ABI bool operator()(weak_ptr<_Tp> const& __x, weak_ptr<_Tp> const& __y) const _NOEXCEPT {
1486 return __x.owner_before(__y);
1487 }
1488 _LIBCPP_HIDE_FROM_ABI bool operator()(shared_ptr<_Tp> const& __x, weak_ptr<_Tp> const& __y) const _NOEXCEPT {
1489 return __x.owner_before(__y);
1490 }
1491 _LIBCPP_HIDE_FROM_ABI bool operator()(weak_ptr<_Tp> const& __x, shared_ptr<_Tp> const& __y) const _NOEXCEPT {
1492 return __x.owner_before(__y);
1493 }
1494 };
1495
1496 #if _LIBCPP_STD_VER >= 17
1497 template <>
1498 struct _LIBCPP_TEMPLATE_VIS owner_less<void> {
1499 template <class _Tp, class _Up>
1500 _LIBCPP_HIDE_FROM_ABI bool operator()(shared_ptr<_Tp> const& __x, shared_ptr<_Up> const& __y) const _NOEXCEPT {
1501 return __x.owner_before(__y);
1502 }
1503 template <class _Tp, class _Up>
1504 _LIBCPP_HIDE_FROM_ABI bool operator()(shared_ptr<_Tp> const& __x, weak_ptr<_Up> const& __y) const _NOEXCEPT {
1505 return __x.owner_before(__y);
1506 }
1507 template <class _Tp, class _Up>
1508 _LIBCPP_HIDE_FROM_ABI bool operator()(weak_ptr<_Tp> const& __x, shared_ptr<_Up> const& __y) const _NOEXCEPT {
1509 return __x.owner_before(__y);
1510 }
1511 template <class _Tp, class _Up>
1512 _LIBCPP_HIDE_FROM_ABI bool operator()(weak_ptr<_Tp> const& __x, weak_ptr<_Up> const& __y) const _NOEXCEPT {
1513 return __x.owner_before(__y);
1514 }
1515 typedef void is_transparent;
1516 };
1517 #endif
1518
1519 template <class _Tp>
1520 class _LIBCPP_TEMPLATE_VIS enable_shared_from_this {
1521 mutable weak_ptr<_Tp> __weak_this_;
1522
1523 protected:
1524 _LIBCPP_HIDE_FROM_ABI _LIBCPP_CONSTEXPR enable_shared_from_this() _NOEXCEPT {}
1525 _LIBCPP_HIDE_FROM_ABI enable_shared_from_this(enable_shared_from_this const&) _NOEXCEPT {}
1526 _LIBCPP_HIDE_FROM_ABI enable_shared_from_this& operator=(enable_shared_from_this const&) _NOEXCEPT { return *this; }
1527 _LIBCPP_HIDE_FROM_ABI ~enable_shared_from_this() {}
1528
1529 public:
1530 _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> shared_from_this() { return shared_ptr<_Tp>(__weak_this_); }
1531 _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp const> shared_from_this() const { return shared_ptr<const _Tp>(__weak_this_); }
1532
1533 #if _LIBCPP_STD_VER >= 17
1534 _LIBCPP_HIDE_FROM_ABI weak_ptr<_Tp> weak_from_this() _NOEXCEPT { return __weak_this_; }
1535
1536 _LIBCPP_HIDE_FROM_ABI weak_ptr<const _Tp> weak_from_this() const _NOEXCEPT { return __weak_this_; }
1537 #endif // _LIBCPP_STD_VER >= 17
1538
1539 template <class _Up>
1540 friend class shared_ptr;
1541 };
1542
1543 template <class _Tp>
1544 struct _LIBCPP_TEMPLATE_VIS hash;
1545
1546 template <class _Tp>
1547 struct _LIBCPP_TEMPLATE_VIS hash<shared_ptr<_Tp> > {
1548 #if _LIBCPP_STD_VER <= 17 || defined(_LIBCPP_ENABLE_CXX20_REMOVED_BINDER_TYPEDEFS)
1549 _LIBCPP_DEPRECATED_IN_CXX17 typedef shared_ptr<_Tp> argument_type;
1550 _LIBCPP_DEPRECATED_IN_CXX17 typedef size_t result_type;
1551 #endif
1552
1553 _LIBCPP_HIDE_FROM_ABI size_t operator()(const shared_ptr<_Tp>& __ptr) const _NOEXCEPT {
1554 return hash<typename shared_ptr<_Tp>::element_type*>()(__ptr.get());
1555 }
1556 };
1557
1558 template <class _CharT, class _Traits, class _Yp>
1559 inline _LIBCPP_HIDE_FROM_ABI basic_ostream<_CharT, _Traits>&
1560 operator<<(basic_ostream<_CharT, _Traits>& __os, shared_ptr<_Yp> const& __p);
1561
1562 #if !defined(_LIBCPP_HAS_NO_THREADS)
1563
1564 class _LIBCPP_EXPORTED_FROM_ABI __sp_mut {
1565 void* __lx_;
1566
1567 public:
1568 void lock() _NOEXCEPT;
1569 void unlock() _NOEXCEPT;
1570
1571 private:
1572 _LIBCPP_CONSTEXPR __sp_mut(void*) _NOEXCEPT;
1573 __sp_mut(const __sp_mut&);
1574 __sp_mut& operator=(const __sp_mut&);
1575
1576 friend _LIBCPP_EXPORTED_FROM_ABI __sp_mut& __get_sp_mut(const void*);
1577 };
1578
1579 _LIBCPP_EXPORTED_FROM_ABI __sp_mut& __get_sp_mut(const void*);
1580
1581 template <class _Tp>
1582 inline _LIBCPP_HIDE_FROM_ABI bool atomic_is_lock_free(const shared_ptr<_Tp>*) {
1583 return false;
1584 }
1585
1586 template <class _Tp>
1587 _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> atomic_load(const shared_ptr<_Tp>* __p) {
1588 __sp_mut& __m = std::__get_sp_mut(__p);
1589 __m.lock();
1590 shared_ptr<_Tp> __q = *__p;
1591 __m.unlock();
1592 return __q;
1593 }
1594
1595 template <class _Tp>
1596 inline _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> atomic_load_explicit(const shared_ptr<_Tp>* __p, memory_order) {
1597 return std::atomic_load(__p);
1598 }
1599
1600 template <class _Tp>
1601 _LIBCPP_HIDE_FROM_ABI void atomic_store(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r) {
1602 __sp_mut& __m = std::__get_sp_mut(__p);
1603 __m.lock();
1604 __p->swap(__r);
1605 __m.unlock();
1606 }
1607
1608 template <class _Tp>
1609 inline _LIBCPP_HIDE_FROM_ABI void atomic_store_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r, memory_order) {
1610 std::atomic_store(__p, __r);
1611 }
1612
1613 template <class _Tp>
1614 _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp> atomic_exchange(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r) {
1615 __sp_mut& __m = std::__get_sp_mut(__p);
1616 __m.lock();
1617 __p->swap(__r);
1618 __m.unlock();
1619 return __r;
1620 }
1621
1622 template <class _Tp>
1623 inline _LIBCPP_HIDE_FROM_ABI shared_ptr<_Tp>
1624 atomic_exchange_explicit(shared_ptr<_Tp>* __p, shared_ptr<_Tp> __r, memory_order) {
1625 return std::atomic_exchange(__p, __r);
1626 }
1627
1628 template <class _Tp>
1629 _LIBCPP_HIDE_FROM_ABI bool
1630 atomic_compare_exchange_strong(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, shared_ptr<_Tp> __w) {
1631 shared_ptr<_Tp> __temp;
1632 __sp_mut& __m = std::__get_sp_mut(__p);
1633 __m.lock();
1634 if (__p->__owner_equivalent(*__v)) {
1635 std::swap(__temp, *__p);
1636 *__p = __w;
1637 __m.unlock();
1638 return true;
1639 }
1640 std::swap(__temp, *__v);
1641 *__v = *__p;
1642 __m.unlock();
1643 return false;
1644 }
1645
1646 template <class _Tp>
1647 inline _LIBCPP_HIDE_FROM_ABI bool
1648 atomic_compare_exchange_weak(shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, shared_ptr<_Tp> __w) {
1649 return std::atomic_compare_exchange_strong(__p, __v, __w);
1650 }
1651
1652 template <class _Tp>
1653 inline _LIBCPP_HIDE_FROM_ABI bool atomic_compare_exchange_strong_explicit(
1654 shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, shared_ptr<_Tp> __w, memory_order, memory_order) {
1655 return std::atomic_compare_exchange_strong(__p, __v, __w);
1656 }
1657
1658 template <class _Tp>
1659 inline _LIBCPP_HIDE_FROM_ABI bool atomic_compare_exchange_weak_explicit(
1660 shared_ptr<_Tp>* __p, shared_ptr<_Tp>* __v, shared_ptr<_Tp> __w, memory_order, memory_order) {
1661 return std::atomic_compare_exchange_weak(__p, __v, __w);
1662 }
1663
1664 #endif // !defined(_LIBCPP_HAS_NO_THREADS)
1665
1666 _LIBCPP_END_NAMESPACE_STD
1667
1668 _LIBCPP_POP_MACROS
1669
1670 #endif // _LIBCPP___MEMORY_SHARED_PTR_H
1671