libstdc++: shared_ptr_base.h Source File

libstdc++

shared_ptr_base.h
Go to the documentation of this file.
1// shared_ptr and weak_ptr implementation details -*- C++ -*-
2
3// Copyright (C) 2007-2026 Free Software Foundation, Inc.
4//
5// This file is part of the GNU ISO C++ Library. This library is free
6// software; you can redistribute it and/or modify it under the
7// terms of the GNU General Public License as published by the
8// Free Software Foundation; either version 3, or (at your option)
9// any later version.
10
11// This library is distributed in the hope that it will be useful,
12// but WITHOUT ANY WARRANTY; without even the implied warranty of
13// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14// GNU General Public License for more details.
15
16// Under Section 7 of GPL version 3, you are granted additional
17// permissions described in the GCC Runtime Library Exception, version
18// 3.1, as published by the Free Software Foundation.
19
20// You should have received a copy of the GNU General Public License and
21// a copy of the GCC Runtime Library Exception along with this program;
22// see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
23// <http://www.gnu.org/licenses/>.
24
25// GCC Note: Based on files from version 1.32.0 of the Boost library.
26
27// shared_count.hpp
28// Copyright (c) 2001, 2002, 2003 Peter Dimov and Multi Media Ltd.
29
30// shared_ptr.hpp
31// Copyright (C) 1998, 1999 Greg Colvin and Beman Dawes.
32// Copyright (C) 2001, 2002, 2003 Peter Dimov
33
34// weak_ptr.hpp
35// Copyright (C) 2001, 2002, 2003 Peter Dimov
36
37// enable_shared_from_this.hpp
38// Copyright (C) 2002 Peter Dimov
39
40// Distributed under the Boost Software License, Version 1.0. (See
41// accompanying file LICENSE_1_0.txt or copy at
42// http://www.boost.org/LICENSE_1_0.txt)
43
44/** @file bits/shared_ptr_base.h
45 * This is an internal header file, included by other library headers.
46 * Do not attempt to use it directly. @headername{memory}
47 */
48
49#ifndef _SHARED_PTR_BASE_H
50#define _SHARED_PTR_BASE_H 1
51
52#include <typeinfo>
53#include <bits/allocated_ptr.h>
54#include <bits/allocator.h>
55#include <bits/exception_defines.h>
56#include <bits/functional_hash.h>
57#include <bits/refwrap.h>
58#include <bits/stl_function.h> // std::less
59#include <bits/unique_ptr.h>
60#include <ext/aligned_buffer.h>
61#include <ext/atomicity.h>
62#include <ext/concurrence.h>
63#if __cplusplus >= 202002L
64# include <compare>
65# include <bits/align.h> // std::align
66# include <bits/stl_uninitialized.h>
67#endif
68
69namespace std _GLIBCXX_VISIBILITY(default)
70{
71_GLIBCXX_BEGIN_NAMESPACE_VERSION
72
73#if _GLIBCXX_USE_DEPRECATED
74#pragma GCC diagnostic push
75#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
76 template<typename> class auto_ptr;
77#pragma GCC diagnostic pop
78#endif
79
80 /**
81 * @brief Exception possibly thrown by @c shared_ptr.
82 * @ingroup exceptions
83 */
84 class bad_weak_ptr : public std::exception
85 {
86 public:
87 virtual char const* what() const noexcept;
88
89 virtual ~bad_weak_ptr() noexcept;
90 };
91
92 // Substitute for bad_weak_ptr object in the case of -fno-exceptions.
93 inline void
94 __throw_bad_weak_ptr()
95 { _GLIBCXX_THROW_OR_ABORT(bad_weak_ptr()); }
96
97 using __gnu_cxx::_Lock_policy;
98 using __gnu_cxx::__default_lock_policy;
99 using __gnu_cxx::_S_single;
100 using __gnu_cxx::_S_mutex;
101 using __gnu_cxx::_S_atomic;
102
103 // Empty helper class except when the template argument is _S_mutex.
104 template<_Lock_policy _Lp>
105 class _Mutex_base
106 {
107 protected:
108 // The atomic policy uses fully-fenced builtins, single doesn't care.
109 enum { _S_need_barriers = 0 };
110 };
111
112 template<>
113 class _Mutex_base<_S_mutex>
114 : public __gnu_cxx::__mutex
115 {
116 protected:
117 // This policy is used when atomic builtins are not available.
118 // The replacement atomic operations might not have the necessary
119 // memory barriers.
120 enum { _S_need_barriers = 1 };
121 };
122
123 template<_Lock_policy _Lp = __default_lock_policy>
124 class _Sp_counted_base
125 : public _Mutex_base<_Lp>
126 {
127 public:
128 _Sp_counted_base() noexcept
129 : _M_use_count(1), _M_weak_count(1) { }
130
131 virtual
132 ~_Sp_counted_base() noexcept
133 { }
134
135 // Called when _M_use_count drops to zero, to release the resources
136 // managed by *this.
137 virtual void
138 _M_dispose() noexcept = 0;
139
140 // Called when _M_weak_count drops to zero.
141 virtual void
142 _M_destroy() noexcept
143 { delete this; }
144
145 virtual void*
146 _M_get_deleter(const std::type_info&) noexcept = 0;
147
148 // Increment the use count (used when the count is greater than zero).
149 void
150 _M_add_ref_copy()
151 { _S_chk(__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, 1)); }
152
153 // Increment the use count if it is non-zero, throw otherwise.
154 void
155 _M_add_ref_lock()
156 {
157 if (!_M_add_ref_lock_nothrow())
158 __throw_bad_weak_ptr();
159 }
160
161 // Increment the use count if it is non-zero.
162 bool
163 _M_add_ref_lock_nothrow() noexcept;
164
165 // Decrement the use count.
166 void
167 _M_release() noexcept;
168
169 // Called by _M_release() when the use count reaches zero.
170 void
171 _M_release_last_use() noexcept
172 {
173 _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_use_count);
174 _M_dispose();
175 // There must be a memory barrier between dispose() and destroy()
176 // to ensure that the effects of dispose() are observed in the
177 // thread that runs destroy().
178 // See http://gcc.gnu.org/ml/libstdc++/2005-11/msg00136.html
179 if (_Mutex_base<_Lp>::_S_need_barriers)
180 {
181 __atomic_thread_fence (__ATOMIC_ACQ_REL);
182 }
183
184 // Be race-detector-friendly. For more info see bits/c++config.
185 _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_weak_count);
186 if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count,
187 -1) == 1)
188 {
189 _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_weak_count);
190 _M_destroy();
191 }
192 }
193
194 // As above, but 'noinline' to reduce code size on the cold path.
195 __attribute__((__noinline__))
196 void
197 _M_release_last_use_cold() noexcept
198 { _M_release_last_use(); }
199
200 // Increment the weak count.
201 void
202 _M_weak_add_ref() noexcept
203 {
204 // _M_weak_count can always use negative values because it cannot be
205 // observed by users (unlike _M_use_count). See _S_chk for details.
206 constexpr _Atomic_word __max = -1;
207 if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, 1) == __max)
208 [[__unlikely__]] __builtin_trap();
209 }
210
211 // Decrement the weak count.
212 void
213 _M_weak_release() noexcept
214 {
215 // Be race-detector-friendly. For more info see bits/c++config.
216 _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_weak_count);
217 if (__gnu_cxx::__exchange_and_add_dispatch(&_M_weak_count, -1) == 1)
218 {
219 _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_weak_count);
220 if (_Mutex_base<_Lp>::_S_need_barriers)
221 {
222 // See _M_release(),
223 // destroy() must observe results of dispose()
224 __atomic_thread_fence (__ATOMIC_ACQ_REL);
225 }
226 _M_destroy();
227 }
228 }
229
230 long
231 _M_get_use_count() const noexcept
232 {
233 // No memory barrier is used here so there is no synchronization
234 // with other threads.
235 auto __count = __atomic_load_n(&_M_use_count, __ATOMIC_RELAXED);
236
237 // If long is wider than _Atomic_word then we can treat _Atomic_word
238 // as unsigned, and so double its usable range. If the widths are the
239 // same then casting to unsigned and then to long is a no-op.
240 return static_cast<_Unsigned_count_type>(__count);
241 }
242
243 private:
244 _Sp_counted_base(_Sp_counted_base const&) = delete;
245 _Sp_counted_base& operator=(_Sp_counted_base const&) = delete;
246
247#pragma GCC diagnostic push
248#pragma GCC diagnostic ignored "-Wignored-attributes"
249 // This is only to be used for arithmetic, not for atomic ops.
250 using _Unsigned_count_type = make_unsigned<_Atomic_word>::type;
251#pragma GCC diagnostic pop
252
253 // Called when incrementing _M_use_count to cause a trap on overflow.
254 // This should be passed the value of the counter before the increment.
255 static void
256 _S_chk(_Atomic_word __count)
257 {
258 constexpr _Atomic_word __max_atomic_word = _Unsigned_count_type(-1)/2;
259
260 // __max is the maximum allowed value for the shared reference count.
261 // All valid reference count values need to fit into [0,LONG_MAX)
262 // because users can observe the count via shared_ptr::use_count().
263 //
264 // When long is wider than _Atomic_word, _M_use_count can go negative
265 // and the cast in _Sp_counted_base::use_count() will turn it into a
266 // positive value suitable for returning to users. The implementation
267 // only cares whether _M_use_count reaches zero after a decrement,
268 // so negative values are not a problem internally.
269 // So when possible, use -1 for __max (incrementing past that would
270 // overflow _M_use_count to 0, which means an empty shared_ptr).
271 //
272 // When long is not wider than _Atomic_word, __max is just the type's
273 // maximum positive value. We cannot use negative counts because they
274 // would not fit in [0,LONG_MAX) after casting to an unsigned type,
275 // which would cause use_count() to return bogus values.
276 constexpr _Atomic_word __max
277 = sizeof(long) > sizeof(_Atomic_word) ? -1 : __max_atomic_word;
278
279 if (__count == __max) [[__unlikely__]]
280 __builtin_trap();
281 }
282
283 _Atomic_word _M_use_count; // #shared
284 _Atomic_word _M_weak_count; // #weak + (#shared != 0)
285 };
286
287 // We use __atomic_add_single and __exchange_and_add_single in the _S_single
288 // member specializations because they use unsigned arithmetic and so avoid
289 // undefined overflow.
290 template<>
291 inline void
292 _Sp_counted_base<_S_single>::_M_add_ref_copy()
293 {
294 _S_chk(_M_use_count);
295 __gnu_cxx::__atomic_add_single(&_M_use_count, 1);
296 }
297
298 template<>
299 inline void
300 _Sp_counted_base<_S_single>::_M_weak_release() noexcept
301 {
302 if (__gnu_cxx::__exchange_and_add_single(&_M_weak_count, -1) == 1)
303 _M_destroy();
304 }
305
306 template<>
307 inline long
308 _Sp_counted_base<_S_single>::_M_get_use_count() const noexcept
309 {
310 return static_cast<_Unsigned_count_type>(_M_use_count);
311 }
312
313
314 template<>
315 inline bool
316 _Sp_counted_base<_S_single>::
317 _M_add_ref_lock_nothrow() noexcept
318 {
319 if (_M_use_count == 0)
320 return false;
321 _M_add_ref_copy();
322 return true;
323 }
324
325 template<>
326 inline bool
327 _Sp_counted_base<_S_mutex>::
328 _M_add_ref_lock_nothrow() noexcept
329 {
330 __gnu_cxx::__scoped_lock sentry(*this);
331 if (auto __c = __gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, 1))
332 _S_chk(__c);
333 else
334 {
335 // Count was zero, so we cannot lock it to get a shared_ptr.
336 // Reset to zero. This isn't racy, because there are no shared_ptr
337 // objects using this count and any other weak_ptr objects using it
338 // must call this function to modify _M_use_count, so would be
339 // synchronized by the mutex.
340 _M_use_count = 0;
341 return false;
342 }
343 return true;
344 }
345
346 template<>
347 inline bool
348 _Sp_counted_base<_S_atomic>::
349 _M_add_ref_lock_nothrow() noexcept
350 {
351 // Perform lock-free add-if-not-zero operation.
352 _Atomic_word __count = _M_get_use_count();
353 do
354 {
355 if (__count == 0)
356 return false;
357 // Replace the current counter value with the old value + 1, as
358 // long as it's not changed meanwhile.
359 }
360 while (!__atomic_compare_exchange_n(&_M_use_count, &__count, __count + 1,
361 true, __ATOMIC_ACQ_REL,
362 __ATOMIC_RELAXED));
363 _S_chk(__count);
364 return true;
365 }
366
367 template<>
368 inline void
369 _Sp_counted_base<_S_single>::_M_release() noexcept
370 {
371 if (__gnu_cxx::__exchange_and_add_single(&_M_use_count, -1) == 1)
372 {
373 _M_dispose();
374 _M_weak_release();
375 }
376 }
377
378 template<>
379 inline void
380 _Sp_counted_base<_S_mutex>::_M_release() noexcept
381 {
382 // Be race-detector-friendly. For more info see bits/c++config.
383 _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_use_count);
384 if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1)
385 {
386 _M_release_last_use();
387 }
388 }
389
390 template<>
391 inline void
392 _Sp_counted_base<_S_atomic>::_M_release() noexcept
393 {
394#pragma GCC diagnostic push
395#pragma GCC diagnostic ignored "-Wc++17-extensions" // if constexpr
396 _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_use_count);
397#if ! _GLIBCXX_TSAN
398 constexpr bool __lock_free
399 = __atomic_always_lock_free(sizeof(long long), 0)
400 && __atomic_always_lock_free(sizeof(_Atomic_word), 0);
401 constexpr bool __double_word
402 = sizeof(long long) == 2 * sizeof(_Atomic_word);
403 // The ref-count members follow the vptr, so are aligned to
404 // alignof(void*).
405 constexpr bool __aligned = __alignof(long long) <= alignof(void*);
406 if constexpr (__lock_free && __double_word && __aligned)
407 {
408 constexpr int __wordbits = __CHAR_BIT__ * sizeof(_Atomic_word);
409 constexpr int __shiftbits = __double_word ? __wordbits : 0;
410 constexpr long long __unique_ref = 1LL + (1LL << __shiftbits);
411 auto __both_counts = reinterpret_cast<long long*>(&_M_use_count);
412
413 _GLIBCXX_SYNCHRONIZATION_HAPPENS_BEFORE(&_M_weak_count);
414 if (__atomic_load_n(__both_counts, __ATOMIC_ACQUIRE) == __unique_ref)
415 {
416 // Both counts are 1, so there are no weak references and
417 // we are releasing the last strong reference. No other
418 // threads can observe the effects of this _M_release()
419 // call (e.g. calling use_count()) without a data race.
420 _M_weak_count = _M_use_count = 0;
421 _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_use_count);
422 _GLIBCXX_SYNCHRONIZATION_HAPPENS_AFTER(&_M_weak_count);
423 _M_dispose();
424 _M_destroy();
425 return;
426 }
427 if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1)
428 [[__unlikely__]]
429 {
430 _M_release_last_use_cold();
431 return;
432 }
433 }
434 else
435#endif
436 if (__gnu_cxx::__exchange_and_add_dispatch(&_M_use_count, -1) == 1)
437 {
438 _M_release_last_use();
439 }
440#pragma GCC diagnostic pop
441 }
442
443 // Forward declarations.
444 template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
445 class __shared_ptr;
446
447 template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
448 class __weak_ptr;
449
450 template<typename _Tp, _Lock_policy _Lp = __default_lock_policy>
451 class __enable_shared_from_this;
452
453 template<typename _Tp>
454 class shared_ptr;
455
456 template<typename _Tp>
457 class weak_ptr;
458
459 template<typename _Tp>
460 struct owner_less;
461
462 template<typename _Tp>
463 class enable_shared_from_this;
464
465 template<_Lock_policy _Lp = __default_lock_policy>
466 class __weak_count;
467
468 template<_Lock_policy _Lp = __default_lock_policy>
469 class __shared_count;
470
471#ifdef __glibcxx_atomic_shared_ptr
472 template<typename>
473 class _Sp_atomic;
474#endif
475
476 // Counted ptr with no deleter or allocator support
477 template<typename _Ptr, _Lock_policy _Lp>
478 class _Sp_counted_ptr final : public _Sp_counted_base<_Lp>
479 {
480 public:
481 explicit
482 _Sp_counted_ptr(_Ptr __p) noexcept
483 : _M_ptr(__p) { }
484
485 virtual void
486 _M_dispose() noexcept
487 { delete _M_ptr; }
488
489 virtual void
490 _M_destroy() noexcept
491 { delete this; }
492
493 virtual void*
494 _M_get_deleter(const std::type_info&) noexcept
495 { return nullptr; }
496
497 _Sp_counted_ptr(const _Sp_counted_ptr&) = delete;
498 _Sp_counted_ptr& operator=(const _Sp_counted_ptr&) = delete;
499
500 private:
501 _Ptr _M_ptr;
502 };
503
504 template<>
505 inline void
506 _Sp_counted_ptr<nullptr_t, _S_single>::_M_dispose() noexcept { }
507
508 template<>
509 inline void
510 _Sp_counted_ptr<nullptr_t, _S_mutex>::_M_dispose() noexcept { }
511
512 template<>
513 inline void
514 _Sp_counted_ptr<nullptr_t, _S_atomic>::_M_dispose() noexcept { }
515
516 // FIXME: once __has_cpp_attribute(__no_unique_address__)) is true for
517 // all supported compilers we can greatly simplify _Sp_ebo_helper.
518 // N.B. unconditionally applying the attribute could change layout for
519 // final types, which currently cannot use EBO so have a unique address.
520
521 template<int _Nm, typename _Tp,
522 bool __use_ebo = !__is_final(_Tp) && __is_empty(_Tp)>
523 struct _Sp_ebo_helper;
524
525 /// Specialization using EBO.
526 template<int _Nm, typename _Tp>
527 struct _Sp_ebo_helper<_Nm, _Tp, true> : private _Tp
528 {
529 explicit _Sp_ebo_helper(const _Tp& __tp) : _Tp(__tp) { }
530 explicit _Sp_ebo_helper(_Tp&& __tp) : _Tp(std::move(__tp)) { }
531
532 static _Tp&
533 _S_get(_Sp_ebo_helper& __eboh) { return static_cast<_Tp&>(__eboh); }
534 };
535
536 /// Specialization not using EBO.
537 template<int _Nm, typename _Tp>
538 struct _Sp_ebo_helper<_Nm, _Tp, false>
539 {
540 explicit _Sp_ebo_helper(const _Tp& __tp) : _M_tp(__tp) { }
541 explicit _Sp_ebo_helper(_Tp&& __tp) : _M_tp(std::move(__tp)) { }
542
543 static _Tp&
544 _S_get(_Sp_ebo_helper& __eboh)
545 { return __eboh._M_tp; }
546
547 private:
548 _Tp _M_tp;
549 };
550
551 // Support for custom deleter and/or allocator
552 template<typename _Ptr, typename _Deleter, typename _Alloc, _Lock_policy _Lp>
553 class _Sp_counted_deleter final : public _Sp_counted_base<_Lp>
554 {
555 class _Impl : _Sp_ebo_helper<0, _Deleter>, _Sp_ebo_helper<1, _Alloc>
556 {
557 typedef _Sp_ebo_helper<0, _Deleter> _Del_base;
558 typedef _Sp_ebo_helper<1, _Alloc> _Alloc_base;
559
560 public:
561 _Impl(_Ptr __p, _Deleter __d, const _Alloc& __a) noexcept
562 : _Del_base(std::move(__d)), _Alloc_base(__a), _M_ptr(__p)
563 { }
564
565 _Deleter& _M_del() noexcept { return _Del_base::_S_get(*this); }
566 _Alloc& _M_alloc() noexcept { return _Alloc_base::_S_get(*this); }
567
568 _Ptr _M_ptr;
569 };
570
571 public:
572 using __allocator_type = __alloc_rebind<_Alloc, _Sp_counted_deleter>;
573
574 // __d(__p) must not throw.
575 _Sp_counted_deleter(_Ptr __p, _Deleter __d) noexcept
576 : _M_impl(__p, std::move(__d), _Alloc()) { }
577
578 // __d(__p) must not throw.
579 _Sp_counted_deleter(_Ptr __p, _Deleter __d, const _Alloc& __a) noexcept
580 : _M_impl(__p, std::move(__d), __a) { }
581
582#pragma GCC diagnostic push // PR tree-optimization/122197
583#pragma GCC diagnostic ignored "-Wfree-nonheap-object"
584 template<typename> class auto_ptr;
585 ~_Sp_counted_deleter() noexcept { }
586#pragma GCC diagnostic pop
587
588 virtual void
589 _M_dispose() noexcept
590 { _M_impl._M_del()(_M_impl._M_ptr); }
591
592 virtual void
593 _M_destroy() noexcept
594 {
595 __allocator_type __a(_M_impl._M_alloc());
596 __allocated_ptr<__allocator_type> __guard_ptr{ __a, this };
597 this->~_Sp_counted_deleter();
598 }
599
600 virtual void*
601 _M_get_deleter(const type_info& __ti [[__gnu__::__unused__]]) noexcept
602 {
603#if __cpp_rtti
604 // _GLIBCXX_RESOLVE_LIB_DEFECTS
605 // 2400. shared_ptr's get_deleter() should use addressof()
606 return __ti == typeid(_Deleter)
607 ? std::__addressof(_M_impl._M_del())
608 : nullptr;
609#else
610 return nullptr;
611#endif
612 }
613
614 private:
615#ifdef __glibcxx_out_ptr
616 template<typename, typename, typename...> friend class out_ptr_t;
617#endif
618 _Impl _M_impl;
619 };
620
621 // helpers for make_shared / allocate_shared
622
623 struct _Sp_make_shared_tag
624 {
625 private:
626 template<typename _Tp, typename _Alloc, _Lock_policy _Lp>
627 friend class _Sp_counted_ptr_inplace;
628
629 static const type_info&
630 _S_ti() noexcept _GLIBCXX_VISIBILITY(default)
631 {
632 alignas(type_info) static constexpr char __tag[sizeof(type_info)] = { };
633 return reinterpret_cast<const type_info&>(__tag);
634 }
635
636 static bool _S_eq(const type_info&) noexcept;
637 };
638
639 template<typename _Alloc>
640 struct _Sp_alloc_shared_tag
641 {
642 const _Alloc& _M_a;
643 };
644
645 template<typename _Tp, typename _Alloc, _Lock_policy _Lp>
646 class _Sp_counted_ptr_inplace final : public _Sp_counted_base<_Lp>
647 {
648 class _Impl : _Sp_ebo_helper<0, _Alloc>
649 {
650 typedef _Sp_ebo_helper<0, _Alloc> _A_base;
651
652 public:
653 explicit _Impl(_Alloc __a) noexcept : _A_base(__a) { }
654
655 _Alloc& _M_alloc() noexcept { return _A_base::_S_get(*this); }
656
657 __gnu_cxx::__aligned_buffer<__remove_cv_t<_Tp>> _M_storage;
658 };
659
660 public:
661 using __allocator_type = __alloc_rebind<_Alloc, _Sp_counted_ptr_inplace>;
662
663 // Alloc parameter is not a reference so doesn't alias anything in __args
664 template<typename... _Args>
665 _Sp_counted_ptr_inplace(_Alloc __a, _Args&&... __args)
666 : _M_impl(__a)
667 {
668 // _GLIBCXX_RESOLVE_LIB_DEFECTS
669 // 2070. allocate_shared should use allocator_traits<A>::construct
670 allocator_traits<_Alloc>::construct(__a, _M_ptr(),
671 std::forward<_Args>(__args)...); // might throw
672 }
673
674#pragma GCC diagnostic push // PR tree-optimization/122197
675#pragma GCC diagnostic ignored "-Warray-bounds"
676 ~_Sp_counted_ptr_inplace() noexcept { }
677#pragma GCC diagnostic pop
678
679 virtual void
680 _M_dispose() noexcept
681 {
682 allocator_traits<_Alloc>::destroy(_M_impl._M_alloc(), _M_ptr());
683 }
684
685 // Override because the allocator needs to know the dynamic type
686 virtual void
687 _M_destroy() noexcept
688 {
689 __allocator_type __a(_M_impl._M_alloc());
690 __allocated_ptr<__allocator_type> __guard_ptr{ __a, this };
691 this->~_Sp_counted_ptr_inplace();
692 }
693
694 private:
695 friend class __shared_count<_Lp>; // To be able to call _M_ptr().
696
697 // No longer used, but code compiled against old libstdc++ headers
698 // might still call it from __shared_ptr ctor to get the pointer out.
699 virtual void*
700 _M_get_deleter(const std::type_info& __ti) noexcept override
701 {
702 // Check for the fake type_info first, so we don't try to access it
703 // as a real type_info object. Otherwise, check if it's the real
704 // type_info for this class. With RTTI enabled we can check directly,
705 // or call a library function to do it.
706 if (&__ti == &_Sp_make_shared_tag::_S_ti()
707 ||
708#if __cpp_rtti
709 __ti == typeid(_Sp_make_shared_tag)
710#else
711 _Sp_make_shared_tag::_S_eq(__ti)
712#endif
713 )
714 return _M_ptr();
715 return nullptr;
716 }
717
718 __remove_cv_t<_Tp>*
719 _M_ptr() noexcept { return _M_impl._M_storage._M_ptr(); }
720
721 _Impl _M_impl;
722 };
723
724#ifdef __glibcxx_smart_ptr_for_overwrite // C++ >= 20 && HOSTED
725 struct _Sp_overwrite_tag { };
726
727 // Partial specialization used for make_shared_for_overwrite<non-array>().
728 // This partial specialization is used when the allocator's value type
729 // is the special _Sp_overwrite_tag type.
730#if __cpp_concepts
731 template<typename _Tp, typename _Alloc, _Lock_policy _Lp>
732 requires is_same_v<typename _Alloc::value_type, _Sp_overwrite_tag>
733 class _Sp_counted_ptr_inplace<_Tp, _Alloc, _Lp> final
734#else
735 template<typename _Tp, template<typename> class _Alloc, _Lock_policy _Lp>
736 class _Sp_counted_ptr_inplace<_Tp, _Alloc<_Sp_overwrite_tag>, _Lp> final
737#endif
738 : public _Sp_counted_base<_Lp>
739 {
740 [[no_unique_address]] _Alloc _M_alloc;
741
742 union {
743 remove_cv_t<_Tp> _M_obj;
744 char _M_unused;
745 };
746
747 friend class __shared_count<_Lp>; // To be able to call _M_ptr().
748
749 auto _M_ptr() noexcept { return std::__addressof(_M_obj); }
750
751 public:
752 using __allocator_type = __alloc_rebind<_Alloc, _Sp_counted_ptr_inplace>;
753
754 _Sp_counted_ptr_inplace(const _Alloc& __a)
755 : _M_alloc(__a)
756 {
757 ::new((void*)_M_ptr()) _Tp; // default-initialized, for overwrite.
758 }
759
760 ~_Sp_counted_ptr_inplace() noexcept { }
761
762 virtual void
763 _M_dispose() noexcept
764 {
765 _M_obj.~_Tp();
766 }
767
768 // Override because the allocator needs to know the dynamic type
769 virtual void
770 _M_destroy() noexcept
771 {
772 using pointer = typename allocator_traits<__allocator_type>::pointer;
773 __allocator_type __a(_M_alloc);
774 auto __p = pointer_traits<pointer>::pointer_to(*this);
775 __allocated_ptr<__allocator_type> __guard_ptr{ __a, __p };
776 this->~_Sp_counted_ptr_inplace();
777 }
778
779 void*
780 _M_get_deleter(const std::type_info&) noexcept override
781 { return nullptr; }
782 };
783#endif // __glibcxx_smart_ptr_for_overwrite
784
785#if __glibcxx_shared_ptr_arrays >= 201707L // C++ >= 20 && HOSTED
786 struct _Sp_overwrite_tag;
787
788 // For make_shared<T[]>, make_shared<T[N]>, allocate_shared<T[]> etc.
789 template<typename _Alloc>
790 struct _Sp_counted_array_base
791 {
792 [[no_unique_address]] _Alloc _M_alloc{};
793 size_t _M_n = 0;
794 bool _M_overwrite = false;
795
796 typename allocator_traits<_Alloc>::pointer
797 _M_alloc_array(size_t __tail)
798 {
799 return allocator_traits<_Alloc>::allocate(_M_alloc, _M_n + __tail);
800 }
801
802 void
803 _M_dealloc_array(typename allocator_traits<_Alloc>::pointer __p,
804 size_t __tail)
805 {
806 allocator_traits<_Alloc>::deallocate(_M_alloc, __p, _M_n + __tail);
807 }
808
809 // Init the array elements
810 template<typename _Init>
811 void
812 _M_init(typename allocator_traits<_Alloc>::value_type* __p,
813 _Init __init)
814 {
815 using _Tp = remove_pointer_t<_Init>;
816 using _Up = typename allocator_traits<_Alloc>::value_type;
817
818 if constexpr (is_same_v<_Init, _Sp_overwrite_tag>)
819 {
820 std::uninitialized_default_construct_n(__p, _M_n);
821 _M_overwrite = true;
822 }
823 else if (__init == nullptr)
824 std::__uninitialized_default_n_a(__p, _M_n, _M_alloc);
825 else if constexpr (!is_array_v<_Tp>)
826 std::__uninitialized_fill_n_a(__p, _M_n, *__init, _M_alloc);
827 else
828 {
829#pragma GCC diagnostic push
830#pragma GCC diagnostic ignored "-Wunused-local-typedefs"
831 struct _Iter
832 {
833 using value_type = _Up;
834 using difference_type = ptrdiff_t;
835 using pointer = const _Up*;
836 using reference = const _Up&;
837 using iterator_category = forward_iterator_tag;
838
839 const _Up* _M_p;
840 size_t _M_len;
841 size_t _M_pos;
842
843 _Iter& operator++() { ++_M_pos; return *this; }
844 _Iter operator++(int) { auto __i(*this); ++_M_pos; return __i; }
845
846 reference operator*() const { return _M_p[_M_pos % _M_len]; }
847 pointer operator->() const { return _M_p + (_M_pos % _M_len); }
848
849 bool operator==(const _Iter& __i) const
850 { return _M_pos == __i._M_pos; }
851 };
852#pragma GCC diagnostic pop
853
854 _Iter __first{_S_first_elem(__init), sizeof(_Tp) / sizeof(_Up)};
855 _Iter __last = __first;
856 __last._M_pos = _M_n;
857 std::__uninitialized_copy_a(__first, __last, __p, _M_alloc);
858 }
859 }
860
861 protected:
862 // Destroy the array elements
863 void
864 _M_dispose_array(typename allocator_traits<_Alloc>::value_type* __p)
865 {
866 if (_M_overwrite)
867 std::destroy_n(__p, _M_n);
868 else
869 {
870 size_t __n = _M_n;
871 while (__n--)
872 allocator_traits<_Alloc>::destroy(_M_alloc, __p + __n);
873 }
874 }
875
876 private:
877 template<typename _Tp>
878 static _Tp*
879 _S_first_elem(_Tp* __p) { return __p; }
880
881 template<typename _Tp, size_t _Nm>
882 static auto
883 _S_first_elem(_Tp (*__p)[_Nm]) { return _S_first_elem(*__p); }
884 };
885
886 // Control block for make_shared<T[]>, make_shared<T[N]> etc. that will be
887 // placed into unused memory at the end of the array.
888 template<typename _Alloc, _Lock_policy _Lp>
889 class _Sp_counted_array final
890 : public _Sp_counted_base<_Lp>, _Sp_counted_array_base<_Alloc>
891 {
892 using pointer = typename allocator_traits<_Alloc>::pointer;
893
894 pointer _M_alloc_ptr;
895
896 auto _M_ptr() const noexcept { return std::to_address(_M_alloc_ptr); }
897
898 friend class __shared_count<_Lp>; // To be able to call _M_ptr().
899
900 public:
901 _Sp_counted_array(const _Sp_counted_array_base<_Alloc>& __a,
902 pointer __p) noexcept
903 : _Sp_counted_array_base<_Alloc>(__a), _M_alloc_ptr(__p)
904 { }
905
906 ~_Sp_counted_array() = default;
907
908 virtual void
909 _M_dispose() noexcept
910 {
911 if (this->_M_n)
912 this->_M_dispose_array(_M_ptr());
913 }
914
915 // Override because the allocator needs to know the dynamic type
916 virtual void
917 _M_destroy() noexcept
918 {
919 _Sp_counted_array_base<_Alloc> __a = *this;
920 pointer __p = _M_alloc_ptr;
921 this->~_Sp_counted_array();
922 __a._M_dealloc_array(__p, _S_tail());
923 }
924
925 // Returns the number of additional array elements that must be
926 // allocated in order to store a _Sp_counted_array at the end.
927 static constexpr size_t
928 _S_tail()
929 {
930 // The array elemenent type.
931 using _Tp = typename allocator_traits<_Alloc>::value_type;
932
933 // The space needed to store a _Sp_counted_array object.
934 size_t __bytes = sizeof(_Sp_counted_array);
935
936 // Add any padding needed for manual alignment within the buffer.
937 if constexpr (alignof(_Tp) < alignof(_Sp_counted_array))
938 __bytes += alignof(_Sp_counted_array) - alignof(_Tp);
939
940 return (__bytes + sizeof(_Tp) - 1) / sizeof(_Tp);
941 }
942
943 void*
944 _M_get_deleter(const std::type_info&) noexcept override
945 { return nullptr; }
946 };
947#endif // __glibcxx_shared_ptr_arrays >= 201707L
948
949 // The default deleter for shared_ptr<T[]> and shared_ptr<T[N]>.
950 struct __sp_array_delete
951 {
952 template<typename _Yp>
953 void operator()(_Yp* __p) const { delete[] __p; }
954 };
955
956 template<_Lock_policy _Lp>
957 class __shared_count
958 {
959 // Prevent _Sp_alloc_shared_tag from matching the shared_ptr(P, D) ctor.
960 template<typename _Tp>
961 struct __not_alloc_shared_tag { using type = void; };
962
963 template<typename _Tp>
964 struct __not_alloc_shared_tag<_Sp_alloc_shared_tag<_Tp>> { };
965
966#if __glibcxx_shared_ptr_arrays >= 201707L // C++ >= 20 && HOSTED
967 template<typename _Alloc>
968 struct __not_alloc_shared_tag<_Sp_counted_array_base<_Alloc>> { };
969#endif
970
971 public:
972 constexpr __shared_count() noexcept : _M_pi(0)
973 { }
974
975 template<typename _Ptr>
976 explicit
977 __shared_count(_Ptr __p) : _M_pi(0)
978 {
979 __try
980 {
981 _M_pi = new _Sp_counted_ptr<_Ptr, _Lp>(__p);
982 }
983 __catch(...)
984 {
985 delete __p;
986 __throw_exception_again;
987 }
988 }
989
990 template<typename _Ptr>
991 __shared_count(_Ptr __p, /* is_array = */ false_type)
992 : __shared_count(__p)
993 { }
994
995 template<typename _Ptr>
996 __shared_count(_Ptr __p, /* is_array = */ true_type)
997 : __shared_count(__p, __sp_array_delete{}, allocator<void>())
998 { }
999
1000 template<typename _Ptr, typename _Deleter,
1001 typename = typename __not_alloc_shared_tag<_Deleter>::type>
1002 __shared_count(_Ptr __p, _Deleter __d)
1003 : __shared_count(__p, std::move(__d), allocator<void>())
1004 { }
1005
1006 template<typename _Ptr, typename _Deleter, typename _Alloc,
1007 typename = typename __not_alloc_shared_tag<_Deleter>::type>
1008 __shared_count(_Ptr __p, _Deleter __d, _Alloc __a) : _M_pi(0)
1009 {
1010 typedef _Sp_counted_deleter<_Ptr, _Deleter, _Alloc, _Lp> _Sp_cd_type;
1011 __try
1012 {
1013 typename _Sp_cd_type::__allocator_type __a2(__a);
1014 auto __guard = std::__allocate_guarded(__a2);
1015 _Sp_cd_type* __mem = __guard.get();
1016 ::new (__mem) _Sp_cd_type(__p, std::move(__d), std::move(__a));
1017 _M_pi = __mem;
1018 __guard = nullptr;
1019 }
1020 __catch(...)
1021 {
1022 __d(__p); // Call _Deleter on __p.
1023 __throw_exception_again;
1024 }
1025 }
1026
1027 template<typename _Tp, typename _Alloc, typename... _Args>
1028 __shared_count(_Tp*& __p, _Sp_alloc_shared_tag<_Alloc> __a,
1029 _Args&&... __args)
1030 {
1031 using _Tp2 = __remove_cv_t<_Tp>;
1032 using _Sp_cp_type = _Sp_counted_ptr_inplace<_Tp2, _Alloc, _Lp>;
1033 typename _Sp_cp_type::__allocator_type __a2(__a._M_a);
1034 auto __guard = std::__allocate_guarded(__a2);
1035 _Sp_cp_type* __mem = __guard.get();
1036 auto __pi = ::new (__mem)
1037 _Sp_cp_type(__a._M_a, std::forward<_Args>(__args)...);
1038 __guard = nullptr;
1039 _M_pi = __pi;
1040 __p = __pi->_M_ptr();
1041 }
1042
1043#if __glibcxx_shared_ptr_arrays >= 201707L // C++ >= 20 && HOSTED
1044 template<typename _Tp, typename _Alloc, typename _Init>
1045 __shared_count(_Tp*& __p, const _Sp_counted_array_base<_Alloc>& __a,
1046 _Init __init)
1047 {
1048 using _Up = remove_all_extents_t<_Tp>;
1049 static_assert(is_same_v<_Up, typename _Alloc::value_type>);
1050
1051 using _Sp_ca_type = _Sp_counted_array<_Alloc, _Lp>;
1052 const size_t __tail = _Sp_ca_type::_S_tail();
1053
1054 struct _Guarded_ptr : _Sp_counted_array_base<_Alloc>
1055 {
1056 typename allocator_traits<_Alloc>::pointer _M_ptr;
1057
1058 _Guarded_ptr(_Sp_counted_array_base<_Alloc> __a)
1059 : _Sp_counted_array_base<_Alloc>(__a),
1060 _M_ptr(this->_M_alloc_array(_Sp_ca_type::_S_tail()))
1061 { }
1062
1063 ~_Guarded_ptr()
1064 {
1065 if (_M_ptr)
1066 this->_M_dealloc_array(_M_ptr, _Sp_ca_type::_S_tail());
1067 }
1068 };
1069
1070 _Guarded_ptr __guard{__a};
1071 _Up* const __raw = std::to_address(__guard._M_ptr);
1072 __guard._M_init(__raw, __init); // might throw
1073
1074 void* __c = __raw + __a._M_n;
1075 if constexpr (alignof(_Up) < alignof(_Sp_ca_type))
1076 {
1077 size_t __space = sizeof(_Up) * __tail;
1078 __c = std::align(alignof(_Sp_ca_type), sizeof(_Sp_ca_type),
1079 __c, __space);
1080 }
1081 auto __pi = ::new(__c) _Sp_ca_type(__guard, __guard._M_ptr);
1082 __guard._M_ptr = nullptr;
1083 _M_pi = __pi;
1084 __p = reinterpret_cast<_Tp*>(__raw);
1085 }
1086#endif
1087
1088#if _GLIBCXX_USE_DEPRECATED
1089#pragma GCC diagnostic push
1090#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
1091 // Special case for auto_ptr<_Tp> to provide the strong guarantee.
1092 template<typename _Tp>
1093 explicit
1094 __shared_count(std::auto_ptr<_Tp>&& __r);
1095#pragma GCC diagnostic pop
1096#endif
1097
1098 // Special case for unique_ptr<_Tp,_Del> to provide the strong guarantee.
1099 template<typename _Tp, typename _Del>
1100 explicit
1101 __shared_count(std::unique_ptr<_Tp, _Del>&& __r) : _M_pi(0)
1102 {
1103 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1104 // 2415. Inconsistency between unique_ptr and shared_ptr
1105 if (__r.get() == nullptr)
1106 return;
1107
1108 using _Ptr = typename unique_ptr<_Tp, _Del>::pointer;
1109 using _Del2 = __conditional_t<is_reference<_Del>::value,
1110 reference_wrapper<typename remove_reference<_Del>::type>,
1111 _Del>;
1112 using _Sp_cd_type
1113 = _Sp_counted_deleter<_Ptr, _Del2, allocator<void>, _Lp>;
1114 using _Alloc = allocator<_Sp_cd_type>;
1115 using _Alloc_traits = allocator_traits<_Alloc>;
1116 _Alloc __a;
1117 _Sp_cd_type* __mem = _Alloc_traits::allocate(__a, 1);
1118 // _GLIBCXX_RESOLVE_LIB_DEFECTS
1119 // 3548. shared_ptr construction from unique_ptr should move
1120 // (not copy) the deleter
1121 _Alloc_traits::construct(__a, __mem, __r.release(),
1122 std::forward<_Del>(__r.get_deleter()));
1123 _M_pi = __mem;
1124 }
1125
1126 // Throw bad_weak_ptr when __r._M_get_use_count() == 0.
1127 explicit __shared_count(const __weak_count<_Lp>& __r);
1128
1129 // Does not throw if __r._M_get_use_count() == 0, caller must check.
1130 explicit
1131 __shared_count(const __weak_count<_Lp>& __r, std::nothrow_t) noexcept;
1132
1133 ~__shared_count() noexcept
1134 {
1135 if (_M_pi != nullptr)
1136 _M_pi->_M_release();
1137 }
1138
1139 __shared_count(const __shared_count& __r) noexcept
1140 : _M_pi(__r._M_pi)
1141 {
1142 if (_M_pi != nullptr)
1143 _M_pi->_M_add_ref_copy();
1144 }
1145
1146 __shared_count&
1147 operator=(const __shared_count& __r) noexcept
1148 {
1149 _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
1150 if (__tmp != _M_pi)
1151 {
1152 if (__tmp != nullptr)
1153 __tmp->_M_add_ref_copy();
1154 if (_M_pi != nullptr)
1155 _M_pi->_M_release();
1156 _M_pi = __tmp;
1157 }
1158 return *this;
1159 }
1160
1161 void
1162 _M_swap(__shared_count& __r) noexcept
1163 {
1164 _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
1165 __r._M_pi = _M_pi;
1166 _M_pi = __tmp;
1167 }
1168
1169 long
1170 _M_get_use_count() const noexcept
1171 { return _M_pi ? _M_pi->_M_get_use_count() : 0; }
1172
1173 bool
1174 _M_unique() const noexcept
1175 { return this->_M_get_use_count() == 1; }
1176
1177 void*
1178 _M_get_deleter(const std::type_info& __ti) const noexcept
1179 { return _M_pi ? _M_pi->_M_get_deleter(__ti) : nullptr; }
1180
1181 bool
1182 _M_less(const __shared_count& __rhs) const noexcept
1183 { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
1184
1185 bool
1186 _M_less(const __weak_count<_Lp>& __rhs) const noexcept
1187 { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
1188
1189#ifdef __glibcxx_smart_ptr_owner_equality // >= C++26
1190 size_t
1191 _M_owner_hash() const noexcept
1192 { return std::hash<_Sp_counted_base<_Lp>*>()(this->_M_pi); }
1193#endif
1194
1195 // Friend function injected into enclosing namespace and found by ADL
1196 friend inline bool
1197 operator==(const __shared_count& __a, const __shared_count& __b) noexcept
1198 { return __a._M_pi == __b._M_pi; }
1199
1200 private:
1201 friend class __weak_count<_Lp>;
1202#ifdef __glibcxx_atomic_shared_ptr
1203 template<typename> friend class _Sp_atomic;
1204#endif
1205#ifdef __glibcxx_out_ptr
1206 template<typename, typename, typename...> friend class out_ptr_t;
1207#endif
1208
1209 _Sp_counted_base<_Lp>* _M_pi;
1210 };
1211
1212
1213 template<_Lock_policy _Lp>
1214 class __weak_count
1215 {
1216 public:
1217 constexpr __weak_count() noexcept : _M_pi(nullptr)
1218 { }
1219
1220 __weak_count(const __shared_count<_Lp>& __r) noexcept
1221 : _M_pi(__r._M_pi)
1222 {
1223 if (_M_pi != nullptr)
1224 _M_pi->_M_weak_add_ref();
1225 }
1226
1227 __weak_count(const __weak_count& __r) noexcept
1228 : _M_pi(__r._M_pi)
1229 {
1230 if (_M_pi != nullptr)
1231 _M_pi->_M_weak_add_ref();
1232 }
1233
1234 __weak_count(__weak_count&& __r) noexcept
1235 : _M_pi(__r._M_pi)
1236 { __r._M_pi = nullptr; }
1237
1238 ~__weak_count() noexcept
1239 {
1240 if (_M_pi != nullptr)
1241 _M_pi->_M_weak_release();
1242 }
1243
1244 __weak_count&
1245 operator=(const __shared_count<_Lp>& __r) noexcept
1246 {
1247 _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
1248 if (__tmp != nullptr)
1249 __tmp->_M_weak_add_ref();
1250 if (_M_pi != nullptr)
1251 _M_pi->_M_weak_release();
1252 _M_pi = __tmp;
1253 return *this;
1254 }
1255
1256 __weak_count&
1257 operator=(const __weak_count& __r) noexcept
1258 {
1259 _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
1260 if (__tmp != nullptr)
1261 __tmp->_M_weak_add_ref();
1262 if (_M_pi != nullptr)
1263 _M_pi->_M_weak_release();
1264 _M_pi = __tmp;
1265 return *this;
1266 }
1267
1268 __weak_count&
1269 operator=(__weak_count&& __r) noexcept
1270 {
1271 if (_M_pi != nullptr)
1272 _M_pi->_M_weak_release();
1273 _M_pi = __r._M_pi;
1274 __r._M_pi = nullptr;
1275 return *this;
1276 }
1277
1278 void
1279 _M_swap(__weak_count& __r) noexcept
1280 {
1281 _Sp_counted_base<_Lp>* __tmp = __r._M_pi;
1282 __r._M_pi = _M_pi;
1283 _M_pi = __tmp;
1284 }
1285
1286 long
1287 _M_get_use_count() const noexcept
1288 { return _M_pi != nullptr ? _M_pi->_M_get_use_count() : 0; }
1289
1290 bool
1291 _M_less(const __weak_count& __rhs) const noexcept
1292 { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
1293
1294 bool
1295 _M_less(const __shared_count<_Lp>& __rhs) const noexcept
1296 { return std::less<_Sp_counted_base<_Lp>*>()(this->_M_pi, __rhs._M_pi); }
1297
1298#ifdef __glibcxx_smart_ptr_owner_equality // >= C++26
1299 size_t
1300 _M_owner_hash() const noexcept
1301 { return std::hash<_Sp_counted_base<_Lp>*>()(this->_M_pi); }
1302#endif
1303
1304 // Friend function injected into enclosing namespace and found by ADL
1305 friend inline bool
1306 operator==(const __weak_count& __a, const __weak_count& __b) noexcept
1307 { return __a._M_pi == __b._M_pi; }
1308
1309 private:
1310 friend class __shared_count<_Lp>;
1311#ifdef __glibcxx_atomic_shared_ptr
1312 template<typename> friend class _Sp_atomic;
1313#endif
1314
1315 _Sp_counted_base<_Lp>* _M_pi;
1316 };
1317
1318 // Now that __weak_count is defined we can define this constructor:
1319 template<_Lock_policy _Lp>
1320 inline
1321 __shared_count<_Lp>::__shared_count(const __weak_count<_Lp>& __r)
1322 : _M_pi(__r._M_pi)
1323 {
1324 if (_M_pi == nullptr || !_M_pi->_M_add_ref_lock_nothrow())
1325 __throw_bad_weak_ptr();
1326 }
1327
1328 // Now that __weak_count is defined we can define this constructor:
1329 template<_Lock_policy _Lp>
1330 inline
1331 __shared_count<_Lp>::
1332 __shared_count(const __weak_count<_Lp>& __r, std::nothrow_t) noexcept
1333 : _M_pi(__r._M_pi)
1334 {
1335 if (_M_pi && !_M_pi->_M_add_ref_lock_nothrow())
1336 _M_pi = nullptr;
1337 }
1338
1339 // Helper traits for shared_ptr of array:
1340
1341 // A pointer type Y* is said to be compatible with a pointer type T* when
1342 // either Y* is convertible to T* or Y is U[N] and T is U cv [].
1343 template<typename _Yp_ptr, typename _Tp_ptr>
1344 struct __sp_compatible_with
1345 : false_type
1346 { };
1347
1348 template<typename _Yp, typename _Tp>
1349 struct __sp_compatible_with<_Yp*, _Tp*>
1350 : is_convertible<_Yp*, _Tp*>::type
1351 { };
1352
1353 template<typename _Up, size_t _Nm>
1354 struct __sp_compatible_with<_Up(*)[_Nm], _Up(*)[]>
1355 : true_type
1356 { };
1357
1358 template<typename _Up, size_t _Nm>
1359 struct __sp_compatible_with<_Up(*)[_Nm], const _Up(*)[]>
1360 : true_type
1361 { };
1362
1363 template<typename _Up, size_t _Nm>
1364 struct __sp_compatible_with<_Up(*)[_Nm], volatile _Up(*)[]>
1365 : true_type
1366 { };
1367
1368 template<typename _Up, size_t _Nm>
1369 struct __sp_compatible_with<_Up(*)[_Nm], const volatile _Up(*)[]>
1370 : true_type
1371 { };
1372
1373 // Test conversion from Y(*)[N] to U(*)[N] without forming invalid type Y[N].
1374 template<typename _Up, size_t _Nm, typename _Yp, typename = void>
1375 struct __sp_is_constructible_arrN
1376 : false_type
1377 { };
1378
1379 template<typename _Up, size_t _Nm, typename _Yp>
1380 struct __sp_is_constructible_arrN<_Up, _Nm, _Yp, __void_t<_Yp[_Nm]>>
1381 : is_convertible<_Yp(*)[_Nm], _Up(*)[_Nm]>::type
1382 { };
1383
1384 // Test conversion from Y(*)[] to U(*)[] without forming invalid type Y[].
1385 template<typename _Up, typename _Yp, typename = void>
1386 struct __sp_is_constructible_arr
1387 : false_type
1388 { };
1389
1390 template<typename _Up, typename _Yp>
1391 struct __sp_is_constructible_arr<_Up, _Yp, __void_t<_Yp[]>>
1392 : is_convertible<_Yp(*)[], _Up(*)[]>::type
1393 { };
1394
1395 // Trait to check if shared_ptr<T> can be constructed from Y*.
1396 template<typename _Tp, typename _Yp>
1397 struct __sp_is_constructible;
1398
1399 // When T is U[N], Y(*)[N] shall be convertible to T*;
1400 template<typename _Up, size_t _Nm, typename _Yp>
1401 struct __sp_is_constructible<_Up[_Nm], _Yp>
1402 : __sp_is_constructible_arrN<_Up, _Nm, _Yp>::type
1403 { };
1404
1405 // when T is U[], Y(*)[] shall be convertible to T*;
1406 template<typename _Up, typename _Yp>
1407 struct __sp_is_constructible<_Up[], _Yp>
1408 : __sp_is_constructible_arr<_Up, _Yp>::type
1409 { };
1410
1411 // otherwise, Y* shall be convertible to T*.
1412 template<typename _Tp, typename _Yp>
1413 struct __sp_is_constructible
1414 : is_convertible<_Yp*, _Tp*>::type
1415 { };
1416
1417
1418 template<typename _Tp>
1419 [[__gnu__::__always_inline__]]
1420 inline _Tp*
1421 __shared_ptr_deref(_Tp* __p)
1422 {
1423 __glibcxx_assert(__p != nullptr);
1424 return __p;
1425 }
1426
1427 // Define operator* and operator-> for shared_ptr<T>.
1428 template<typename _Tp, _Lock_policy _Lp,
1429 bool = is_array<_Tp>::value, bool = is_void<_Tp>::value>
1430 class __shared_ptr_access
1431 {
1432 public:
1433 using element_type = _Tp;
1434
1435 element_type&
1436 operator*() const noexcept
1437 { return *std::__shared_ptr_deref(_M_get()); }
1438
1439 element_type*
1440 operator->() const noexcept
1441 {
1442 _GLIBCXX_DEBUG_PEDASSERT(_M_get() != nullptr);
1443 return _M_get();
1444 }
1445
1446 private:
1447 element_type*
1448 _M_get() const noexcept
1449 { return static_cast<const __shared_ptr<_Tp, _Lp>*>(this)->get(); }
1450 };
1451
1452 // Define operator-> for shared_ptr<cv void>.
1453 template<typename _Tp, _Lock_policy _Lp>
1454 class __shared_ptr_access<_Tp, _Lp, false, true>
1455 {
1456 public:
1457 using element_type = _Tp;
1458
1459 element_type*
1460 operator->() const noexcept
1461 {
1462 auto __ptr = static_cast<const __shared_ptr<_Tp, _Lp>*>(this)->get();
1463 _GLIBCXX_DEBUG_PEDASSERT(__ptr != nullptr);
1464 return __ptr;
1465 }
1466 };
1467
1468 // Define operator[] for shared_ptr<T[]> and shared_ptr<T[N]>.
1469 template<typename _Tp, _Lock_policy _Lp>
1470 class __shared_ptr_access<_Tp, _Lp, true, false>
1471 {
1472 public:
1473 using element_type = typename remove_extent<_Tp>::type;
1474
1475#if __cplusplus <= 201402L
1476 [[__deprecated__("shared_ptr<T[]>::operator* is absent from C++17")]]
1477 element_type&
1478 operator*() const noexcept
1479 { return *std::__shared_ptr_deref(_M_get()); }
1480
1481 [[__deprecated__("shared_ptr<T[]>::operator-> is absent from C++17")]]
1482 element_type*
1483 operator->() const noexcept
1484 {
1485 _GLIBCXX_DEBUG_PEDASSERT(_M_get() != nullptr);
1486 return _M_get();
1487 }
1488#endif
1489
1490#pragma GCC diagnostic push
1491#pragma GCC diagnostic ignored "-Wc++17-extensions"
1492 element_type&
1493 operator[](ptrdiff_t __i) const noexcept
1494 {
1495 if constexpr (extent<_Tp>::value)
1496 __glibcxx_assert(__i < extent<_Tp>::value);
1497 return std::__shared_ptr_deref(_M_get())[__i];
1498 }
1499#pragma GCC diagnostic pop
1500
1501 private:
1502 element_type*
1503 _M_get() const noexcept
1504 { return static_cast<const __shared_ptr<_Tp, _Lp>*>(this)->get(); }
1505 };
1506
1507 template<typename _Tp, _Lock_policy _Lp>
1508 class __shared_ptr
1509 : public __shared_ptr_access<_Tp, _Lp>
1510 {
1511 public:
1512 using element_type = typename remove_extent<_Tp>::type;
1513
1514 private:
1515 // Constraint for taking ownership of a pointer of type _Yp*:
1516 template<typename _Yp>
1517 using _SafeConv
1518 = typename enable_if<__sp_is_constructible<_Tp, _Yp>::value>::type;
1519
1520 // Constraint for construction from shared_ptr and weak_ptr:
1521 template<typename _Yp, typename _Res = void>
1522 using _Compatible = typename
1523 enable_if<__sp_compatible_with<_Yp*, _Tp*>::value, _Res>::type;
1524
1525 // Constraint for assignment from shared_ptr and weak_ptr:
1526 template<typename _Yp>
1527 using _Assignable = _Compatible<_Yp, __shared_ptr&>;
1528
1529 // Constraint for construction from unique_ptr:
1530 template<typename _Yp, typename _Del, typename _Res = void,
1531 typename _Ptr = typename unique_ptr<_Yp, _Del>::pointer>
1532 using _UniqCompatible = __enable_if_t<__and_<
1533 __sp_compatible_with<_Yp*, _Tp*>,
1534 is_convertible<_Ptr, element_type*>,
1535 is_move_constructible<_Del>
1536 >::value, _Res>;
1537
1538 // Constraint for assignment from unique_ptr:
1539 template<typename _Yp, typename _Del>
1540 using _UniqAssignable = _UniqCompatible<_Yp, _Del, __shared_ptr&>;
1541
1542 public:
1543
1544#if __cplusplus > 201402L
1545 using weak_type = __weak_ptr<_Tp, _Lp>;
1546#endif
1547
1548 constexpr __shared_ptr() noexcept
1549 : _M_ptr(0), _M_refcount()
1550 { }
1551
1552 template<typename _Yp, typename = _SafeConv<_Yp>>
1553 explicit
1554 __shared_ptr(_Yp* __p)
1555 : _M_ptr(__p), _M_refcount(__p, typename is_array<_Tp>::type())
1556 {
1557 static_assert( !is_void<_Yp>::value, "incomplete type" );
1558 static_assert( sizeof(_Yp) > 0, "incomplete type" );
1559 _M_enable_shared_from_this_with(__p);
1560 }
1561
1562 template<typename _Yp, typename _Deleter, typename = _SafeConv<_Yp>>
1563 __shared_ptr(_Yp* __p, _Deleter __d)
1564 : _M_ptr(__p), _M_refcount(__p, std::move(__d))
1565 {
1566 static_assert(__is_invocable<_Deleter&, _Yp*&>::value,
1567 "deleter expression d(p) is well-formed");
1568 _M_enable_shared_from_this_with(__p);
1569 }
1570
1571 template<typename _Yp, typename _Deleter, typename _Alloc,
1572 typename = _SafeConv<_Yp>>
1573 __shared_ptr(_Yp* __p, _Deleter __d, _Alloc __a)
1574 : _M_ptr(__p), _M_refcount(__p, std::move(__d), std::move(__a))
1575 {
1576 static_assert(__is_invocable<_Deleter&, _Yp*&>::value,
1577 "deleter expression d(p) is well-formed");
1578 _M_enable_shared_from_this_with(__p);
1579 }
1580
1581 template<typename _Deleter>
1582 __shared_ptr(nullptr_t __p, _Deleter __d)
1583 : _M_ptr(0), _M_refcount(__p, std::move(__d))
1584 { }
1585
1586 template<typename _Deleter, typename _Alloc>
1587 __shared_ptr(nullptr_t __p, _Deleter __d, _Alloc __a)
1588 : _M_ptr(0), _M_refcount(__p, std::move(__d), std::move(__a))
1589 { }
1590
1591 // Aliasing constructor
1592 template<typename _Yp>
1593 __shared_ptr(const __shared_ptr<_Yp, _Lp>& __r,
1594 element_type* __p) noexcept
1595 : _M_ptr(__p), _M_refcount(__r._M_refcount) // never throws
1596 { }
1597
1598 // Aliasing constructor
1599 template<typename _Yp>
1600 __shared_ptr(__shared_ptr<_Yp, _Lp>&& __r,
1601 element_type* __p) noexcept
1602 : _M_ptr(__p), _M_refcount()
1603 {
1604 _M_refcount._M_swap(__r._M_refcount);
1605 __r._M_ptr = nullptr;
1606 }
1607
1608 __shared_ptr(const __shared_ptr&) noexcept = default;
1609 __shared_ptr& operator=(const __shared_ptr&) noexcept = default;
1610 ~__shared_ptr() = default;
1611
1612 template<typename _Yp, typename = _Compatible<_Yp>>
1613 __shared_ptr(const __shared_ptr<_Yp, _Lp>& __r) noexcept
1614 : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount)
1615 { }
1616
1617 __shared_ptr(__shared_ptr&& __r) noexcept
1618 : _M_ptr(__r._M_ptr), _M_refcount()
1619 {
1620 _M_refcount._M_swap(__r._M_refcount);
1621 __r._M_ptr = nullptr;
1622 }
1623
1624 template<typename _Yp, typename = _Compatible<_Yp>>
1625 __shared_ptr(__shared_ptr<_Yp, _Lp>&& __r) noexcept
1626 : _M_ptr(__r._M_ptr), _M_refcount()
1627 {
1628 _M_refcount._M_swap(__r._M_refcount);
1629 __r._M_ptr = nullptr;
1630 }
1631
1632 template<typename _Yp, typename = _Compatible<_Yp>>
1633 explicit __shared_ptr(const __weak_ptr<_Yp, _Lp>& __r)
1634 : _M_refcount(__r._M_refcount) // may throw
1635 {
1636 // It is now safe to copy __r._M_ptr, as
1637 // _M_refcount(__r._M_refcount) did not throw.
1638 _M_ptr = __r._M_ptr;
1639 }
1640
1641 // If an exception is thrown this constructor has no effect.
1642 template<typename _Yp, typename _Del,
1643 typename = _UniqCompatible<_Yp, _Del>>
1644 __shared_ptr(unique_ptr<_Yp, _Del>&& __r)
1645 : _M_ptr(__r.get()), _M_refcount()
1646 {
1647 auto __raw = std::__to_address(__r.get());
1648 _M_refcount = __shared_count<_Lp>(std::move(__r));
1649 _M_enable_shared_from_this_with(__raw);
1650 }
1651
1652#if __cplusplus <= 201402L && _GLIBCXX_USE_DEPRECATED
1653 protected:
1654 // If an exception is thrown this constructor has no effect.
1655 template<typename _Tp1, typename _Del,
1656 typename enable_if<__and_<
1657 __not_<is_array<_Tp>>, is_array<_Tp1>,
1658 is_convertible<typename unique_ptr<_Tp1, _Del>::pointer, _Tp*>
1659 >::value, bool>::type = true>
1660 __shared_ptr(unique_ptr<_Tp1, _Del>&& __r, __sp_array_delete)
1661 : _M_ptr(__r.get()), _M_refcount()
1662 {
1663 auto __raw = std::__to_address(__r.get());
1664 _M_refcount = __shared_count<_Lp>(std::move(__r));
1665 _M_enable_shared_from_this_with(__raw);
1666 }
1667 public:
1668#endif
1669
1670#if _GLIBCXX_USE_DEPRECATED
1671#pragma GCC diagnostic push
1672#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
1673 // Postcondition: use_count() == 1 and __r.get() == 0
1674 template<typename _Yp, typename = _Compatible<_Yp>>
1675 __shared_ptr(auto_ptr<_Yp>&& __r);
1676#pragma GCC diagnostic pop
1677#endif
1678
1679 constexpr __shared_ptr(nullptr_t) noexcept : __shared_ptr() { }
1680
1681 template<typename _Yp>
1682 _Assignable<_Yp>
1683 operator=(const __shared_ptr<_Yp, _Lp>& __r) noexcept
1684 {
1685 _M_ptr = __r._M_ptr;
1686 _M_refcount = __r._M_refcount; // __shared_count::op= doesn't throw
1687 return *this;
1688 }
1689
1690#if _GLIBCXX_USE_DEPRECATED
1691#pragma GCC diagnostic push
1692#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
1693 template<typename _Yp>
1694 _Assignable<_Yp>
1695 operator=(auto_ptr<_Yp>&& __r)
1696 {
1697 __shared_ptr(std::move(__r)).swap(*this);
1698 return *this;
1699 }
1700#pragma GCC diagnostic pop
1701#endif
1702
1703 __shared_ptr&
1704 operator=(__shared_ptr&& __r) noexcept
1705 {
1706 __shared_ptr(std::move(__r)).swap(*this);
1707 return *this;
1708 }
1709
1710 template<class _Yp>
1711 _Assignable<_Yp>
1712 operator=(__shared_ptr<_Yp, _Lp>&& __r) noexcept
1713 {
1714 __shared_ptr(std::move(__r)).swap(*this);
1715 return *this;
1716 }
1717
1718 template<typename _Yp, typename _Del>
1719 _UniqAssignable<_Yp, _Del>
1720 operator=(unique_ptr<_Yp, _Del>&& __r)
1721 {
1722 __shared_ptr(std::move(__r)).swap(*this);
1723 return *this;
1724 }
1725
1726 void
1727 reset() noexcept
1728 { __shared_ptr().swap(*this); }
1729
1730 template<typename _Yp>
1731 _SafeConv<_Yp>
1732 reset(_Yp* __p) // _Yp must be complete.
1733 {
1734 // Catch self-reset errors.
1735 __glibcxx_assert(__p == nullptr || __p != _M_ptr);
1736 __shared_ptr(__p).swap(*this);
1737 }
1738
1739 template<typename _Yp, typename _Deleter>
1740 _SafeConv<_Yp>
1741 reset(_Yp* __p, _Deleter __d)
1742 { __shared_ptr(__p, std::move(__d)).swap(*this); }
1743
1744 template<typename _Yp, typename _Deleter, typename _Alloc>
1745 _SafeConv<_Yp>
1746 reset(_Yp* __p, _Deleter __d, _Alloc __a)
1747 { __shared_ptr(__p, std::move(__d), std::move(__a)).swap(*this); }
1748
1749 /// Return the stored pointer.
1750 element_type*
1751 get() const noexcept
1752 { return _M_ptr; }
1753
1754 /// Return true if the stored pointer is not null.
1755 explicit operator bool() const noexcept
1756 { return _M_ptr != nullptr; }
1757
1758 /// Return true if use_count() == 1.
1759 bool
1760 unique() const noexcept
1761 { return _M_refcount._M_unique(); }
1762
1763 /// If *this owns a pointer, return the number of owners, otherwise zero.
1764 long
1765 use_count() const noexcept
1766 { return _M_refcount._M_get_use_count(); }
1767
1768 /// Exchange both the owned pointer and the stored pointer.
1769 void
1770 swap(__shared_ptr<_Tp, _Lp>& __other) noexcept
1771 {
1772 std::swap(_M_ptr, __other._M_ptr);
1773 _M_refcount._M_swap(__other._M_refcount);
1774 }
1775
1776 /** @brief Define an ordering based on ownership.
1777 *
1778 * This function defines a strict weak ordering between two shared_ptr
1779 * or weak_ptr objects, such that one object is less than the other
1780 * unless they share ownership of the same pointer, or are both empty.
1781 * @{
1782 */
1783 template<typename _Tp1>
1784 bool
1785 owner_before(__shared_ptr<_Tp1, _Lp> const& __rhs) const noexcept
1786 { return _M_refcount._M_less(__rhs._M_refcount); }
1787
1788 template<typename _Tp1>
1789 bool
1790 owner_before(__weak_ptr<_Tp1, _Lp> const& __rhs) const noexcept
1791 { return _M_refcount._M_less(__rhs._M_refcount); }
1792 /// @}
1793
1794#ifdef __glibcxx_smart_ptr_owner_equality // >= C++26
1795 size_t owner_hash() const noexcept { return _M_refcount._M_owner_hash(); }
1796
1797 template<typename _Tp1>
1798 bool
1799 owner_equal(__shared_ptr<_Tp1, _Lp> const& __rhs) const noexcept
1800 { return _M_refcount == __rhs._M_refcount; }
1801
1802 template<typename _Tp1>
1803 bool
1804 owner_equal(__weak_ptr<_Tp1, _Lp> const& __rhs) const noexcept
1805 { return _M_refcount == __rhs._M_refcount; }
1806#endif
1807
1808 protected:
1809 // This constructor is non-standard, it is used by allocate_shared.
1810 template<typename _Alloc, typename... _Args>
1811 __shared_ptr(_Sp_alloc_shared_tag<_Alloc> __tag, _Args&&... __args)
1812 : _M_ptr(), _M_refcount(_M_ptr, __tag, std::forward<_Args>(__args)...)
1813 { _M_enable_shared_from_this_with(_M_ptr); }
1814
1815 template<typename _Tp1, _Lock_policy _Lp1, typename _Alloc,
1816 typename... _Args>
1817 friend __shared_ptr<_Tp1, _Lp1>
1818 __allocate_shared(const _Alloc& __a, _Args&&... __args);
1819
1820#if __glibcxx_shared_ptr_arrays >= 201707L // C++ >= 20 && HOSTED
1821 // This constructor is non-standard, it is used by allocate_shared<T[]>.
1822 template<typename _Alloc, typename _Init = const remove_extent_t<_Tp>*>
1823 __shared_ptr(const _Sp_counted_array_base<_Alloc>& __a,
1824 _Init __init = nullptr)
1825 : _M_ptr(), _M_refcount(_M_ptr, __a, __init)
1826 { }
1827#endif
1828
1829 // This constructor is used by __weak_ptr::lock() and
1830 // shared_ptr::shared_ptr(const weak_ptr&, std::nothrow_t).
1831 __shared_ptr(const __weak_ptr<_Tp, _Lp>& __r, std::nothrow_t) noexcept
1832 : _M_refcount(__r._M_refcount, std::nothrow)
1833 {
1834 _M_ptr = _M_refcount._M_get_use_count() ? __r._M_ptr : nullptr;
1835 }
1836
1837 friend class __weak_ptr<_Tp, _Lp>;
1838
1839 private:
1840
1841 template<typename _Yp>
1842 using __esft_base_t = decltype(__enable_shared_from_this_base(
1843 std::declval<const __shared_count<_Lp>&>(),
1844 std::declval<_Yp*>()));
1845
1846 // Detect an accessible and unambiguous enable_shared_from_this base.
1847 template<typename _Yp, typename = void>
1848 struct __has_esft_base
1849 : false_type { };
1850
1851 template<typename _Yp>
1852 struct __has_esft_base<_Yp, __void_t<__esft_base_t<_Yp>>>
1853 : __not_<is_array<_Tp>> { }; // No enable shared_from_this for arrays
1854
1855 template<typename _Yp, typename _Yp2 = typename remove_cv<_Yp>::type>
1856 typename enable_if<__has_esft_base<_Yp2>::value>::type
1857 _M_enable_shared_from_this_with(_Yp* __p) noexcept
1858 {
1859 if (auto __base = __enable_shared_from_this_base(_M_refcount, __p))
1860 __base->_M_weak_assign(const_cast<_Yp2*>(__p), _M_refcount);
1861 }
1862
1863 template<typename _Yp, typename _Yp2 = typename remove_cv<_Yp>::type>
1864 typename enable_if<!__has_esft_base<_Yp2>::value>::type
1865 _M_enable_shared_from_this_with(_Yp*) noexcept
1866 { }
1867
1868 void*
1869 _M_get_deleter(const std::type_info& __ti) const noexcept
1870 { return _M_refcount._M_get_deleter(__ti); }
1871
1872 template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr;
1873 template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;
1874
1875 template<typename _Del, typename _Tp1, _Lock_policy _Lp1>
1876 friend _Del* get_deleter(const __shared_ptr<_Tp1, _Lp1>&) noexcept;
1877
1878 template<typename _Del, typename _Tp1>
1879 friend _Del* get_deleter(const shared_ptr<_Tp1>&) noexcept;
1880
1881#ifdef __glibcxx_atomic_shared_ptr
1882 friend _Sp_atomic<shared_ptr<_Tp>>;
1883#endif
1884#ifdef __glibcxx_out_ptr
1885 template<typename, typename, typename...> friend class out_ptr_t;
1886#endif
1887
1888 element_type* _M_ptr; // Contained pointer.
1889 __shared_count<_Lp> _M_refcount; // Reference counter.
1890 };
1891
1892
1893 // 20.7.2.2.7 shared_ptr comparisons
1894 template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
1895 inline bool
1896 operator==(const __shared_ptr<_Tp1, _Lp>& __a,
1897 const __shared_ptr<_Tp2, _Lp>& __b) noexcept
1898 { return __a.get() == __b.get(); }
1899
1900 template<typename _Tp, _Lock_policy _Lp>
1901 inline bool
1902 operator==(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
1903 { return !__a; }
1904
1905#ifdef __cpp_lib_three_way_comparison
1906 template<typename _Tp, typename _Up, _Lock_policy _Lp>
1907 inline strong_ordering
1908 operator<=>(const __shared_ptr<_Tp, _Lp>& __a,
1909 const __shared_ptr<_Up, _Lp>& __b) noexcept
1910 { return compare_three_way()(__a.get(), __b.get()); }
1911
1912 template<typename _Tp, _Lock_policy _Lp>
1913 inline strong_ordering
1914 operator<=>(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
1915 {
1916 using pointer = typename __shared_ptr<_Tp, _Lp>::element_type*;
1917 return compare_three_way()(__a.get(), static_cast<pointer>(nullptr));
1918 }
1919#else
1920 template<typename _Tp, _Lock_policy _Lp>
1921 inline bool
1922 operator==(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
1923 { return !__a; }
1924
1925 template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
1926 inline bool
1927 operator!=(const __shared_ptr<_Tp1, _Lp>& __a,
1928 const __shared_ptr<_Tp2, _Lp>& __b) noexcept
1929 { return __a.get() != __b.get(); }
1930
1931 template<typename _Tp, _Lock_policy _Lp>
1932 inline bool
1933 operator!=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
1934 { return (bool)__a; }
1935
1936 template<typename _Tp, _Lock_policy _Lp>
1937 inline bool
1938 operator!=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
1939 { return (bool)__a; }
1940
1941 template<typename _Tp, typename _Up, _Lock_policy _Lp>
1942 inline bool
1943 operator<(const __shared_ptr<_Tp, _Lp>& __a,
1944 const __shared_ptr<_Up, _Lp>& __b) noexcept
1945 {
1946 using _Tp_elt = typename __shared_ptr<_Tp, _Lp>::element_type;
1947 using _Up_elt = typename __shared_ptr<_Up, _Lp>::element_type;
1948 using _Vp = typename common_type<_Tp_elt*, _Up_elt*>::type;
1949 return less<_Vp>()(__a.get(), __b.get());
1950 }
1951
1952 template<typename _Tp, _Lock_policy _Lp>
1953 inline bool
1954 operator<(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
1955 {
1956 using _Tp_elt = typename __shared_ptr<_Tp, _Lp>::element_type;
1957 return less<_Tp_elt*>()(__a.get(), nullptr);
1958 }
1959
1960 template<typename _Tp, _Lock_policy _Lp>
1961 inline bool
1962 operator<(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
1963 {
1964 using _Tp_elt = typename __shared_ptr<_Tp, _Lp>::element_type;
1965 return less<_Tp_elt*>()(nullptr, __a.get());
1966 }
1967
1968 template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
1969 inline bool
1970 operator<=(const __shared_ptr<_Tp1, _Lp>& __a,
1971 const __shared_ptr<_Tp2, _Lp>& __b) noexcept
1972 { return !(__b < __a); }
1973
1974 template<typename _Tp, _Lock_policy _Lp>
1975 inline bool
1976 operator<=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
1977 { return !(nullptr < __a); }
1978
1979 template<typename _Tp, _Lock_policy _Lp>
1980 inline bool
1981 operator<=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
1982 { return !(__a < nullptr); }
1983
1984 template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
1985 inline bool
1986 operator>(const __shared_ptr<_Tp1, _Lp>& __a,
1987 const __shared_ptr<_Tp2, _Lp>& __b) noexcept
1988 { return (__b < __a); }
1989
1990 template<typename _Tp, _Lock_policy _Lp>
1991 inline bool
1992 operator>(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
1993 { return nullptr < __a; }
1994
1995 template<typename _Tp, _Lock_policy _Lp>
1996 inline bool
1997 operator>(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
1998 { return __a < nullptr; }
1999
2000 template<typename _Tp1, typename _Tp2, _Lock_policy _Lp>
2001 inline bool
2002 operator>=(const __shared_ptr<_Tp1, _Lp>& __a,
2003 const __shared_ptr<_Tp2, _Lp>& __b) noexcept
2004 { return !(__a < __b); }
2005
2006 template<typename _Tp, _Lock_policy _Lp>
2007 inline bool
2008 operator>=(const __shared_ptr<_Tp, _Lp>& __a, nullptr_t) noexcept
2009 { return !(__a < nullptr); }
2010
2011 template<typename _Tp, _Lock_policy _Lp>
2012 inline bool
2013 operator>=(nullptr_t, const __shared_ptr<_Tp, _Lp>& __a) noexcept
2014 { return !(nullptr < __a); }
2015#endif // three-way comparison
2016
2017 // 20.7.2.2.8 shared_ptr specialized algorithms.
2018 template<typename _Tp, _Lock_policy _Lp>
2019 inline void
2020 swap(__shared_ptr<_Tp, _Lp>& __a, __shared_ptr<_Tp, _Lp>& __b) noexcept
2021 { __a.swap(__b); }
2022
2023 // 20.7.2.2.9 shared_ptr casts
2024
2025 // The seemingly equivalent code:
2026 // shared_ptr<_Tp, _Lp>(static_cast<_Tp*>(__r.get()))
2027 // will eventually result in undefined behaviour, attempting to
2028 // delete the same object twice.
2029 /// static_pointer_cast
2030 template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
2031 inline __shared_ptr<_Tp, _Lp>
2032 static_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
2033 {
2034 using _Sp = __shared_ptr<_Tp, _Lp>;
2035 return _Sp(__r, static_cast<typename _Sp::element_type*>(__r.get()));
2036 }
2037
2038 // The seemingly equivalent code:
2039 // shared_ptr<_Tp, _Lp>(const_cast<_Tp*>(__r.get()))
2040 // will eventually result in undefined behaviour, attempting to
2041 // delete the same object twice.
2042 /// const_pointer_cast
2043 template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
2044 inline __shared_ptr<_Tp, _Lp>
2045 const_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
2046 {
2047 using _Sp = __shared_ptr<_Tp, _Lp>;
2048 return _Sp(__r, const_cast<typename _Sp::element_type*>(__r.get()));
2049 }
2050
2051 // The seemingly equivalent code:
2052 // shared_ptr<_Tp, _Lp>(dynamic_cast<_Tp*>(__r.get()))
2053 // will eventually result in undefined behaviour, attempting to
2054 // delete the same object twice.
2055 /// dynamic_pointer_cast
2056 template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
2057 inline __shared_ptr<_Tp, _Lp>
2058 dynamic_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
2059 {
2060 using _Sp = __shared_ptr<_Tp, _Lp>;
2061 if (auto* __p = dynamic_cast<typename _Sp::element_type*>(__r.get()))
2062 return _Sp(__r, __p);
2063 return _Sp();
2064 }
2065
2066#if __cplusplus > 201402L
2067 template<typename _Tp, typename _Tp1, _Lock_policy _Lp>
2068 inline __shared_ptr<_Tp, _Lp>
2069 reinterpret_pointer_cast(const __shared_ptr<_Tp1, _Lp>& __r) noexcept
2070 {
2071 using _Sp = __shared_ptr<_Tp, _Lp>;
2072 return _Sp(__r, reinterpret_cast<typename _Sp::element_type*>(__r.get()));
2073 }
2074#endif
2075
2076 template<typename _Tp, _Lock_policy _Lp>
2077 class __weak_ptr
2078 {
2079 public:
2080 using element_type = typename remove_extent<_Tp>::type;
2081
2082 private:
2083 template<typename _Yp, typename _Res = void>
2084 using _Compatible = typename
2085 enable_if<__sp_compatible_with<_Yp*, _Tp*>::value, _Res>::type;
2086
2087 // Constraint for assignment from shared_ptr and weak_ptr:
2088 template<typename _Yp>
2089 using _Assignable = _Compatible<_Yp, __weak_ptr&>;
2090
2091#pragma GCC diagnostic push
2092#pragma GCC diagnostic ignored "-Wc++17-extensions" // if constexpr
2093 // Helper for construction/assignment:
2094 template<typename _Yp>
2095 static element_type*
2096 _S_safe_upcast(const __weak_ptr<_Yp, _Lp>& __r)
2097 {
2098 // We know that _Yp and _Tp are compatible, that is, either
2099 // _Yp* is convertible to _Tp* or _Yp is U[N] and _Tp is U cv [].
2100
2101 // If _Yp is the same as _Tp after removing extents and cv
2102 // qualifications, there's no pointer adjustments to do. This
2103 // also allows us to support incomplete types.
2104 using _At = typename remove_cv<typename remove_extent<_Tp>::type>::type;
2105 using _Bt = typename remove_cv<typename remove_extent<_Yp>::type>::type;
2106 if constexpr (is_same<_At, _Bt>::value)
2107 return __r._M_ptr;
2108 // If they're not the same type, but they're both scalars,
2109 // we again don't need any adjustment. This allows us to support e.g.
2110 // pointers to a differently cv qualified type X.
2111 else if constexpr (__and_<is_scalar<_At>, is_scalar<_Bt>>::value)
2112 return __r._M_ptr;
2113#if _GLIBCXX_USE_BUILTIN_TRAIT(__builtin_is_virtual_base_of)
2114 // If _Tp is not a virtual base class of _Yp, the pointer
2115 // conversion does not require dereferencing __r._M_ptr; just
2116 // rely on the implicit conversion.
2117 else if constexpr (!__builtin_is_virtual_base_of(_Tp, _Yp))
2118 return __r._M_ptr;
2119#endif
2120 // Expensive path; must lock() and do the pointer conversion while
2121 // a shared_ptr keeps the pointee alive (because we may need
2122 // to dereference).
2123 else
2124 return __r.lock().get();
2125 }
2126#pragma GCC diagnostic pop
2127
2128 public:
2129 constexpr __weak_ptr() noexcept
2130 : _M_ptr(nullptr), _M_refcount()
2131 { }
2132
2133 __weak_ptr(const __weak_ptr&) noexcept = default;
2134
2135 ~__weak_ptr() = default;
2136
2137 // The "obvious" converting constructor implementation:
2138 //
2139 // template<typename _Tp1>
2140 // __weak_ptr(const __weak_ptr<_Tp1, _Lp>& __r)
2141 // : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount) // never throws
2142 // { }
2143 //
2144 // has a serious problem.
2145 //
2146 // __r._M_ptr may already have been invalidated. The _M_ptr(__r._M_ptr)
2147 // conversion may require access to *__r._M_ptr (virtual inheritance).
2148 //
2149 // It is not possible to avoid spurious access violations since
2150 // in multithreaded programs __r._M_ptr may be invalidated at any point.
2151 template<typename _Yp, typename = _Compatible<_Yp>>
2152 __weak_ptr(const __weak_ptr<_Yp, _Lp>& __r) noexcept
2153 : _M_ptr(_S_safe_upcast(__r)), _M_refcount(__r._M_refcount)
2154 { }
2155
2156 template<typename _Yp, typename = _Compatible<_Yp>>
2157 __weak_ptr(const __shared_ptr<_Yp, _Lp>& __r) noexcept
2158 : _M_ptr(__r._M_ptr), _M_refcount(__r._M_refcount)
2159 { }
2160
2161 __weak_ptr(__weak_ptr&& __r) noexcept
2162 : _M_ptr(__r._M_ptr), _M_refcount(std::move(__r._M_refcount))
2163 { __r._M_ptr = nullptr; }
2164
2165 template<typename _Yp, typename = _Compatible<_Yp>>
2166 __weak_ptr(__weak_ptr<_Yp, _Lp>&& __r) noexcept
2167 : _M_ptr(_S_safe_upcast(__r)), _M_refcount(std::move(__r._M_refcount))
2168 { __r._M_ptr = nullptr; }
2169
2170 __weak_ptr&
2171 operator=(const __weak_ptr& __r) noexcept = default;
2172
2173 template<typename _Yp>
2174 _Assignable<_Yp>
2175 operator=(const __weak_ptr<_Yp, _Lp>& __r) noexcept
2176 {
2177 _M_ptr = _S_safe_upcast(__r);
2178 _M_refcount = __r._M_refcount;
2179 return *this;
2180 }
2181
2182 template<typename _Yp>
2183 _Assignable<_Yp>
2184 operator=(const __shared_ptr<_Yp, _Lp>& __r) noexcept
2185 {
2186 _M_ptr = __r._M_ptr;
2187 _M_refcount = __r._M_refcount;
2188 return *this;
2189 }
2190
2191 __weak_ptr&
2192 operator=(__weak_ptr&& __r) noexcept
2193 {
2194 __weak_ptr(std::move(__r)).swap(*this);
2195 return *this;
2196 }
2197
2198 template<typename _Yp>
2199 _Assignable<_Yp>
2200 operator=(__weak_ptr<_Yp, _Lp>&& __r) noexcept
2201 {
2202 _M_ptr = _S_safe_upcast(__r);
2203 _M_refcount = std::move(__r._M_refcount);
2204 __r._M_ptr = nullptr;
2205 return *this;
2206 }
2207
2208 __shared_ptr<_Tp, _Lp>
2209 lock() const noexcept
2210 { return __shared_ptr<_Tp, _Lp>(*this, std::nothrow); }
2211
2212 long
2213 use_count() const noexcept
2214 { return _M_refcount._M_get_use_count(); }
2215
2216 bool
2217 expired() const noexcept
2218 { return _M_refcount._M_get_use_count() == 0; }
2219
2220 template<typename _Tp1>
2221 bool
2222 owner_before(const __shared_ptr<_Tp1, _Lp>& __rhs) const noexcept
2223 { return _M_refcount._M_less(__rhs._M_refcount); }
2224
2225 template<typename _Tp1>
2226 bool
2227 owner_before(const __weak_ptr<_Tp1, _Lp>& __rhs) const noexcept
2228 { return _M_refcount._M_less(__rhs._M_refcount); }
2229
2230#ifdef __glibcxx_smart_ptr_owner_equality // >= C++26
2231 size_t owner_hash() const noexcept { return _M_refcount._M_owner_hash(); }
2232
2233 template<typename _Tp1>
2234 bool
2235 owner_equal(const __shared_ptr<_Tp1, _Lp> & __rhs) const noexcept
2236 { return _M_refcount == __rhs._M_refcount; }
2237
2238 template<typename _Tp1>
2239 bool
2240 owner_equal(const __weak_ptr<_Tp1, _Lp> & __rhs) const noexcept
2241 { return _M_refcount == __rhs._M_refcount; }
2242#endif
2243
2244 void
2245 reset() noexcept
2246 { __weak_ptr().swap(*this); }
2247
2248 void
2249 swap(__weak_ptr& __s) noexcept
2250 {
2251 std::swap(_M_ptr, __s._M_ptr);
2252 _M_refcount._M_swap(__s._M_refcount);
2253 }
2254
2255 private:
2256 // Used by __enable_shared_from_this.
2257 void
2258 _M_assign(_Tp* __ptr, const __shared_count<_Lp>& __refcount) noexcept
2259 {
2260 if (use_count() == 0)
2261 {
2262 _M_ptr = __ptr;
2263 _M_refcount = __refcount;
2264 }
2265 }
2266
2267 template<typename _Tp1, _Lock_policy _Lp1> friend class __shared_ptr;
2268 template<typename _Tp1, _Lock_policy _Lp1> friend class __weak_ptr;
2269 friend class __enable_shared_from_this<_Tp, _Lp>;
2270 friend class enable_shared_from_this<_Tp>;
2271#ifdef __glibcxx_atomic_shared_ptr
2272 friend _Sp_atomic<weak_ptr<_Tp>>;
2273#endif
2274
2275 element_type* _M_ptr; // Contained pointer.
2276 __weak_count<_Lp> _M_refcount; // Reference counter.
2277 };
2278
2279 // 20.7.2.3.6 weak_ptr specialized algorithms.
2280 template<typename _Tp, _Lock_policy _Lp>
2281 inline void
2282 swap(__weak_ptr<_Tp, _Lp>& __a, __weak_ptr<_Tp, _Lp>& __b) noexcept
2283 { __a.swap(__b); }
2284
2285#pragma GCC diagnostic push
2286#pragma GCC diagnostic ignored "-Wdeprecated-declarations"
2287 template<typename _Tp, typename _Tp1>
2288 struct _Sp_owner_less : public binary_function<_Tp, _Tp, bool>
2289 {
2290 bool
2291 operator()(const _Tp& __lhs, const _Tp& __rhs) const noexcept
2292 { return __lhs.owner_before(__rhs); }
2293
2294 bool
2295 operator()(const _Tp& __lhs, const _Tp1& __rhs) const noexcept
2296 { return __lhs.owner_before(__rhs); }
2297
2298 bool
2299 operator()(const _Tp1& __lhs, const _Tp& __rhs) const noexcept
2300 { return __lhs.owner_before(__rhs); }
2301 };
2302#pragma GCC diagnostic pop
2303
2304 template<>
2305 struct _Sp_owner_less<void, void>
2306 {
2307 template<typename _Tp, typename _Up>
2308 auto
2309 operator()(const _Tp& __lhs, const _Up& __rhs) const noexcept
2310 -> decltype(__lhs.owner_before(__rhs))
2311 { return __lhs.owner_before(__rhs); }
2312
2313 using is_transparent = void;
2314 };
2315
2316 template<typename _Tp, _Lock_policy _Lp>
2317 struct owner_less<__shared_ptr<_Tp, _Lp>>
2318 : public _Sp_owner_less<__shared_ptr<_Tp, _Lp>, __weak_ptr<_Tp, _Lp>>
2319 { };
2320
2321 template<typename _Tp, _Lock_policy _Lp>
2322 struct owner_less<__weak_ptr<_Tp, _Lp>>
2323 : public _Sp_owner_less<__weak_ptr<_Tp, _Lp>, __shared_ptr<_Tp, _Lp>>
2324 { };
2325
2326
2327 template<typename _Tp, _Lock_policy _Lp>
2328 class __enable_shared_from_this
2329 {
2330 protected:
2331 constexpr __enable_shared_from_this() noexcept { }
2332
2333 __enable_shared_from_this(const __enable_shared_from_this&) noexcept { }
2334
2335 __enable_shared_from_this&
2336 operator=(const __enable_shared_from_this&) noexcept
2337 { return *this; }
2338
2339 ~__enable_shared_from_this() { }
2340
2341 public:
2342 __shared_ptr<_Tp, _Lp>
2343 shared_from_this()
2344 { return __shared_ptr<_Tp, _Lp>(this->_M_weak_this); }
2345
2346 __shared_ptr<const _Tp, _Lp>
2347 shared_from_this() const
2348 { return __shared_ptr<const _Tp, _Lp>(this->_M_weak_this); }
2349
2350#if __cplusplus > 201402L || !defined(__STRICT_ANSI__) // c++1z or gnu++11
2351 __weak_ptr<_Tp, _Lp>
2352 weak_from_this() noexcept
2353 { return this->_M_weak_this; }
2354
2355 __weak_ptr<const _Tp, _Lp>
2356 weak_from_this() const noexcept
2357 { return this->_M_weak_this; }
2358#endif
2359
2360 private:
2361 template<typename _Tp1>
2362 void
2363 _M_weak_assign(_Tp1* __p, const __shared_count<_Lp>& __n) const noexcept
2364 { _M_weak_this._M_assign(__p, __n); }
2365
2366 friend const __enable_shared_from_this*
2367 __enable_shared_from_this_base(const __shared_count<_Lp>&,
2368 const __enable_shared_from_this* __p)
2369 { return __p; }
2370
2371 template<typename, _Lock_policy>
2372 friend class __shared_ptr;
2373
2374 mutable __weak_ptr<_Tp, _Lp> _M_weak_this;
2375 };
2376
2377 template<typename _Tp, _Lock_policy _Lp = __default_lock_policy,
2378 typename _Alloc, typename... _Args>
2379 inline __shared_ptr<_Tp, _Lp>
2380 __allocate_shared(const _Alloc& __a, _Args&&... __args)
2381 {
2382 static_assert(!is_array<_Tp>::value, "make_shared<T[]> not supported");
2383
2384 return __shared_ptr<_Tp, _Lp>(_Sp_alloc_shared_tag<_Alloc>{__a},
2385 std::forward<_Args>(__args)...);
2386 }
2387
2388 template<typename _Tp, _Lock_policy _Lp = __default_lock_policy,
2389 typename... _Args>
2390 inline __shared_ptr<_Tp, _Lp>
2391 __make_shared(_Args&&... __args)
2392 {
2393 typedef typename std::remove_const<_Tp>::type _Tp_nc;
2394 return std::__allocate_shared<_Tp, _Lp>(std::allocator<_Tp_nc>(),
2395 std::forward<_Args>(__args)...);
2396 }
2397
2398 /// std::hash specialization for __shared_ptr.
2399 template<typename _Tp, _Lock_policy _Lp>
2400 struct hash<__shared_ptr<_Tp, _Lp>>
2401 : public __hash_base<size_t, __shared_ptr<_Tp, _Lp>>
2402 {
2403 size_t
2404 operator()(const __shared_ptr<_Tp, _Lp>& __s) const noexcept
2405 {
2406 return hash<typename __shared_ptr<_Tp, _Lp>::element_type*>()(
2407 __s.get());
2408 }
2409 };
2410
2411_GLIBCXX_END_NAMESPACE_VERSION
2412} // namespace
2413
2414#endif // _SHARED_PTR_BASE_H
compare
typeinfo
align.h
allocator.h
functional_hash.h
refwrap.h
stl_function.h
stl_uninitialized.h
unique_ptr.h
allocated_ptr.h
exception_defines.h
aligned_buffer.h
atomicity.h
concurrence.h
std::operator*
constexpr complex< _Tp > operator*(const complex< _Tp > &__x, const complex< _Tp > &__y)
Return new complex value x times y.
Definition complex:434
std::uninitialized_default_construct_n
constexpr _ForwardIterator uninitialized_default_construct_n(_ForwardIterator __first, _Size __count)
Default-initializes objects in the range [first,first+count).
Definition stl_uninitialized.h:1250
std::align
void * align(size_t __align, size_t __size, void *&__ptr, size_t &__space) noexcept
Fit aligned storage in buffer.
Definition align.h:60
std::to_address
constexpr _Tp * to_address(_Tp *__ptr) noexcept
Obtain address referenced by a pointer to an object.
Definition ptr_traits.h:232
std::true_type
__bool_constant< true > true_type
The type used as a compile-time boolean with true value.
Definition type_traits:119
std::false_type
__bool_constant< false > false_type
The type used as a compile-time boolean with false value.
Definition type_traits:122
std::declval
auto declval() noexcept -> decltype(__declval< _Tp >(0))
Definition type_traits:2714
std::move
constexpr std::remove_reference< _Tp >::type && move(_Tp &&__t) noexcept
Convert a value to an rvalue.
Definition move.h:138
std::__addressof
constexpr _Tp * __addressof(_Tp &__r) noexcept
Same as C++11 std::addressof.
Definition move.h:52
std::forward
constexpr _Tp && forward(typename std::remove_reference< _Tp >::type &__t) noexcept
Forward an lvalue.
Definition move.h:72
std::lock
void lock(_L1 &__l1, _L2 &__l2, _L3 &... __l3)
Generic lock.
Definition mutex:686
std
ISO C++ entities toplevel namespace is std.
std::dynamic_pointer_cast
__shared_ptr< _Tp, _Lp > dynamic_pointer_cast(const __shared_ptr< _Tp1, _Lp > &__r) noexcept
dynamic_pointer_cast
Definition shared_ptr_base.h:2058
std::static_pointer_cast
__shared_ptr< _Tp, _Lp > static_pointer_cast(const __shared_ptr< _Tp1, _Lp > &__r) noexcept
static_pointer_cast
Definition shared_ptr_base.h:2032
std::const_pointer_cast
__shared_ptr< _Tp, _Lp > const_pointer_cast(const __shared_ptr< _Tp1, _Lp > &__r) noexcept
const_pointer_cast
Definition shared_ptr_base.h:2045
__gnu_debug::__base
constexpr _Iterator __base(_Iterator __it)
Definition helper_functions.h:339
std::hash
Primary class template hash.
Definition functional_hash.h:106
std::enable_if
Define a member typedef type only if a boolean constant is true.
Definition type_traits:137
std::remove_cv
remove_cv
Definition type_traits:1792
std::is_void
is_void
Definition type_traits:331
std::is_array
is_array
Definition type_traits:608
std::is_scalar
is_scalar
Definition type_traits:874
std::is_same
is_same
Definition type_traits:1622
std::common_type
common_type
Definition type_traits:2573
std::allocator_traits::construct
static constexpr void construct(_Alloc &__a, _Tp *__p, _Args &&... __args) noexcept(_S_nothrow_construct< _Tp, _Args... >())
Construct an object of type _Tp
Definition bits/alloc_traits.h:457
std::allocator_traits::destroy
static constexpr void destroy(_Alloc &__a, _Tp *__p) noexcept(_S_nothrow_destroy< _Tp >())
Destroy an object of type _Tp.
Definition bits/alloc_traits.h:476
std::exception
Base class for all library exceptions.
Definition exception.h:62
std::owner_less
Primary template owner_less.
Definition bits/shared_ptr.h:893
std::enable_shared_from_this
Base class allowing use of the member function shared_from_this.
Definition bits/shared_ptr.h:977
std::auto_ptr
A simple smart pointer providing strict ownership semantics.
Definition auto_ptr.h:94
std::bad_weak_ptr
Exception possibly thrown by shared_ptr.
Definition shared_ptr_base.h:85
std::bad_weak_ptr::what
virtual char const * what() const noexcept
std::binary_function
Definition stl_function.h:135
std::less
One of the comparison functors.
Definition stl_function.h:404