std::atomic<std::shared_ptr>

 

C++

Compiler support

Freestanding and hosted

Language

Standard library headers

Named requirements

Feature test macros (C++20)

Language support library

Concepts library (C++20)

Metaprogramming library (C++11)

Diagnostics library

General utilities library

Strings library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Numerics library

Localizations library

Input/output library

Filesystem library (C++17)

Regular expressions library (C++11)

Concurrency support library (C++11)

Technical specifications

Symbols index

External libraries

 

Utilities library

Language support Type support (basic types, RTTI) Library feature-test macros (C++20) Dynamic memory management Program utilities Coroutine support (C++20) Variadic functions is_constant_evaluated (C++20) launder (C++17) initializer_list (C++11) source_location (C++20) Three-way comparison (C++20) three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)    is_eqis_neqis_ltis_lteqis_gtis_gteq (C++20)(C++20)(C++20)(C++20)(C++20)(C++20)

General utilities Date and time Function objects Formatting library (C++20) bitset hash (C++11) Relational operators (deprecated in C++20) rel_ops::operator!=rel_ops::operator> rel_ops::operator<=rel_ops::operator>= Integer comparison functions cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)    cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) Swap and type operations swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) Common vocabulary types pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23) Elementary string conversions to_chars (C++17) from_chars (C++17) chars_format (C++17)

 

Dynamic memory management

Smart pointers unique_ptr (C++11) shared_ptr (C++11) weak_ptr (C++11) auto_ptr (until C++17) owner_less (C++11) enable_shared_from_this (C++11) bad_weak_ptr (C++11) default_delete (C++11) out_ptr_t (C++23) inout_ptr_t (C++23) Allocators allocator allocator_traits (C++11) allocation_result (C++23) allocate_at_least (C++23) allocator_arg (C++11) uses_allocator (C++11) uses_allocator_construction_args (C++20) make_obj_using_allocator (C++20) uninitialized_construct_using_allocator (C++20) scoped_allocator_adaptor (C++11) pmr::polymorphic_allocator (C++17) Memory resources pmr::memory_resource (C++17) pmr::get_default_resource (C++17) pmr::set_default_resource (C++17) pmr::new_delete_resource (C++17) pmr::null_memory_resource (C++17) pmr::synchronized_pool_resource (C++17) pmr::unsynchronized_pool_resource (C++17) pmr::monotonic_buffer_resource (C++17) pmr::pool_options (C++17) Uninitialized storage raw_storage_iterator (until C++20) get_temporary_buffer (until C++20) return_temporary_buffer (until C++20)

Uninitialized memory algorithms uninitialized_copy uninitialized_fill uninitialized_move (C++17) uninitialized_default_construct (C++17) uninitialized_value_construct (C++17) destroy (C++17) destroy_at (C++17) uninitialized_copy_n (C++11) uninitialized_fill_n uninitialized_move_n (C++17) uninitialized_default_construct_n (C++17) uninitialized_value_construct_n (C++17) destroy_n (C++17) construct_at (C++20) Constrained uninitialized memory algorithms ranges::uninitialized_copy (C++20) ranges::uninitialized_fill (C++20) ranges::uninitialized_move (C++20) ranges::uninitialized_default_construct (C++20) ranges::uninitialized_value_construct (C++20) ranges::destroy (C++20) ranges::destroy_at (C++20) ranges::uninitialized_copy_n (C++20) ranges::uninitialized_fill_n (C++20) ranges::uninitialized_move_n (C++20) ranges::uninitialized_default_construct_n (C++20) ranges::uninitialized_value_construct_n (C++20) ranges::destroy_n (C++20) ranges::construct_at (C++20) Garbage collection support declare_reachable (C++11)(until C++23) undeclare_reachable (C++11)(until C++23) declare_no_pointers (C++11)(until C++23) undeclare_no_pointers (C++11)(until C++23) pointer_safety (C++11)(until C++23) get_pointer_safety (C++11)(until C++23) Miscellaneous pointer_traits (C++11) to_address (C++20) addressof (C++11) align (C++11) assume_aligned (C++20) C Library malloc aligned_alloc (C++17) calloc realloc free Low level memory management operator new operator new[] operator delete operator delete[] get_new_handler set_new_handler bad_alloc bad_array_new_length nothrow_t align_val_t destroying_delete_t new_handler nothrow

 

std::shared_ptr

Member functions

shared_ptr::shared_ptr

shared_ptr::~shared_ptr

shared_ptr::operator=

Modifiers

shared_ptr::reset

shared_ptr::swap

Observers

shared_ptr::get

shared_ptr::operator*shared_ptr::operator->

shared_ptr::operator[] (C++17)

shared_ptr::use_count

shared_ptr::unique (until C++20)

shared_ptr::operator bool

shared_ptr::owner_before

Non-member functions

std::swap

make_sharedmake_shared_for_overwrite (C++20)

allocate_sharedallocate_shared_for_overwrite (C++20)

static_pointer_castdynamic_pointer_castconst_pointer_castreinterpret_pointer_cast (C++17)

get_deleter

operator==operator!=operator<operator<=operator>operator>=operator<=> (until C++20)(until C++20)(until C++20)(until C++20)(until C++20)(C++20)

operator<<

atomic_xxx functions (deprecated in C++20)

std::atomic<std::shared_ptr> (C++20)

std::hash

Deduction guides(C++17)

 

Defined in header <memory>
template <class T> struct std::atomic<std::shared_ptr<T>>;		(since C++20)

The partial template specialization of std::atomic for std::shared_ptr<T> allows users to manipulate shared_ptr objects atomically.

If multiple threads of execution access the same std::shared_ptr object without synchronization and any of those accesses uses a non-const member function of shared_ptr then a data race will occur unless all such access is performed through an instance of std::atomic<std::shared_ptr> (or, deprecated as of C++20, through the standalone functions for atomic access to std::shared_ptr).

Associated use_count increments are guaranteed to be part of the atomic operation. Associated use_count decrements are sequenced after the atomic operation, but are not required to be part of it, except for the use_count change when overriding expected in a failed CAS. Any associated deletion and deallocation are sequenced after the atomic update step and are not part of the atomic operation.

Note that the control block of a shared_ptr is thread-safe: different non-atomic std::shared_ptr objects can be accessed using mutable operations, such as operator= or reset, simultaneously by multiple threads, even when these instances are copies, and share the same control block internally.

The type T may be an incomplete type.

Member types

Member type	Definition
value_type	std::shared_ptr<T>

Member functions

All non-specialized std::atomic functions are also provided by this specialization, and no additional member functions.

atomic<shared_ptr<T>>::atomic

constexpr atomic() noexcept = default;	(1)
constexpr atomic( std::nullptr_t ) noexcept : atomic() {}	(2)
atomic( std::shared_ptr<T> desired ) noexcept;	(3)
atomic( const atomic& ) = delete;	(4)

1,2) Initializes the underlying shared_ptr<T> to the null value.

3) Initializes the underlying shared_ptr<T> to a copy of desired. As with any std::atomic type, initialization is not an atomic operation.

4) Atomic types are not copy/move constructible

atomic<shared_ptr<T>>::operator=

void operator=( const atomic& ) = delete;	(1)
void operator=( std::shared_ptr<T> desired ) noexcept;	(2)

1) Atomic types are not copy/move assignable

2) Value assignment, equivalent to store(desired)

atomic<shared_ptr<T>>::is_lock_free

bool is_lock_free() const noexcept;

Returns true if the atomic operations on all objects of this type are lock-free, false otherwise.

atomic<shared_ptr<T>>::store

void store( std::shared_ptr<T> desired,             std::memory_order order = std::memory_order_seq_cst ) noexcept;

Atomically replaces the value of *this with the value of desired as if by p.swap(desired) where p is the underlying std::shared_ptr<T>. Memory is ordered according to order. The behavior is undefined if order is std::memory_order_consume, std::memory_order_acquire, or std::memory_order_acq_rel.

atomic<shared_ptr<T>>::load

std::shared_ptr<T> load( std::memory_order order = std::memory_order_seq_cst ) const noexcept;

Atomically returns a copy of the underlying shared pointer. Memory is ordered according to order. The behavior is undefined if order is std::memory_order_release or std::memory_order_acq_rel.

atomic<shared_ptr<T>>::operator std::shared_ptr<T>

operator std::shared_ptr<T>() const noexcept;

Equivalent to return load();

atomic<shared_ptr<T>>::exchange

std::shared_ptr<T> exchange( std::shared_ptr<T> desired,                              std::memory_order order = std::memory_order_seq_cst ) noexcept;

Atomically replaces the underlying std::shared_ptr<T> with desired as if by p.swap(desired) where p is the underlying std::shared_ptr<T> and returns a copy of the value that p had immediately before the swap. Memory is ordered according to order. This is an atomic read-modify-write operation.

atomic<shared_ptr<T>>::compare_exchange_weak, compare_exchange_strong

bool compare_exchange_strong( std::shared_ptr<T>& expected, std::shared_ptr<T> desired,                               std::memory_order success, std::memory_order failure ) noexcept;	(1)
bool compare_exchange_weak( std::shared_ptr<T>& expected, std::shared_ptr<T> desired,                             std::memory_order success, std::memory_order failure ) noexcept;	(2)
bool compare_exchange_strong( std::shared_ptr<T>& expected, std::shared_ptr<T> desired,                               std::memory_order order = std::memory_order_seq_cst ) noexcept;	(3)
bool compare_exchange_weak( std::shared_ptr<T>& expected, std::shared_ptr<T> desired,                             std::memory_order order = std::memory_order_seq_cst ) noexcept;	(4)

1) If the underlying std::shared_ptr<T> stores the same T* as expected and shares ownership with it, or if both underlying and expected are empty, assigns from desired to the underlying std::shared_ptr<T>, returns true, and orders memory according to success, otherwise assigns from the underlying std::shared_ptr<T> to expected, returns false, and orders memory according to failure. The behavior is undefined if failure is std::memory_order_release or std::memory_order_acq_rel. On success, the operation is an atomic read-modify-write operation on *this and expected is not accessed after the atomic update. On failure, the operation is an atomic load operation on *this and expected is updated with the existing value read from the atomic object. This update to expected's use_count is part of this atomic operation, although the write itself (and any subsequent deallocation/destruction) is not required to be.

2) Same as (1), but may also fail spuriously.

3) Equivalent to: return compare_exchange_strong(expected, desired, order, fail_order);, where fail_order is the same as order except that std:memory_order_acq_rel is replaced by std::memory_order_acquire and std::memory_order_release is replaced by std::memory_order_relaxed.

4) Equivalent to: return compare_exchange_weak(expected, desired, order, fail_order); where fail_order is the same as order except that std::memory_order_acq_rel is replaced by std::memory_order_acquire and std::memory_order_release is replaced by std::memory_order_relaxed.

atomic<shared_ptr<T>>::wait

void wait( std::shared_ptr<T> old            std::memory_order order = std::memory_order_seq_cst ) const noexcept;

Performs an atomic waiting operation.

Compares load(order) with old and if they are equivalent then blocks until *this is notified by notify_one() or notify_all(). This is repeated until load(order) changes. This function is guaranteed to return only if value has changed, even if underlying implementation unblocks spuriously.

Memory is ordered according to order. The behavior is undefined if order is std::memory_order_release or std::memory_order_acq_rel.

Notes: two shared_ptrs are equivalent if they store the same pointer and either share ownership or are both empty.

atomic<shared_ptr<T>>::notify_one

void notify_one() noexcept;

Performs an atomic notifying operation.

If there is a thread blocked in atomic waiting operations (i.e. wait()) on *this, then unblocks at least one such thread; otherwise does nothing.

atomic<shared_ptr<T>>::notify_all

void notify_all() noexcept;

Performs an atomic notifying operation.

Unblocks all threads blocked in atomic waiting operations (i.e. wait()) on *this, if there are any; otherwise does nothing.

Member constants

The only standard std::atomic member constant is_always_lock_free is also provided by this specialization.

atomic<shared_ptr<T>>::is_always_lock_free

static constexpr bool is_always_lock_free = /*implementation-defined*/;

Notes

Feature-test macro:

__cpp_lib_atomic_shared_ptr

Defect reports

The following behavior-changing defect reports were applied retroactively to previously published C++ standards.

DR	Applied to	Behavior as published	Correct behavior
LWG 3661	C++20	atomic<shared_ptr<T>> was not constant-initializable from nullptr	made constant-initializable

See also

atomic (C++11)

atomic class template and specializations for bool, integral, and pointer types (class template)