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 functions
All non-specialized std::atomic functions are also provided by this specialization, and no additional member functions.
constexpr atomic() noexcept = default;
atomic(std::shared_ptr<T> desired) noexcept;
atomic(const atomic&) = delete;
shared_ptr<T>to default-constructed value
shared_ptr<T>to a copy of
desired. As with any std::atomic type, initialization is not an atomic operation.
void operator=(const atomic&) = delete;
void operator=(std::shared_ptr<T> desired) noexcept;
bool is_lock_free() const noexcept;
Returns true if the atomic operations on all objects of this type are lock-free, false otherwise.
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.
operator std::shared_ptr<T>() const noexcept;
Equivalent to return load();
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.
expectedand shares ownership with it, or if both underlying and
expectedare empty, assigns from
desiredto 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
failureis std::memory_order_release or std::memory_order_acq_rel. On success, the operation is an atomic read-modify-write operation on *this and
expectedis not accessed after the atomic update. On failure, the operation is an atomic load operation on *this and
expectedis 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.
fail_orderis the same as
orderexcept 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.
 Member constants
The only standard std::atomic member constant
is_always_lock_free is also provided by this specialization.
static constexpr bool is_always_lock_free = /*implementation-defined*/;
|This section is incomplete|
Reason: no example
 See also
| atomic class template and specializations for bool, integral, and pointer types |