std::atomic(std::weak_ptr)
| template <class T> struct std::atomic<std::weak_ptr<T>>; |
(since C++20) | |
The partial template specialization of std::atomic for std::weak_ptr<T> allows users to manipulate weak_ptr objects atomically.
If multiple threads of execution access the same std::weak_ptr object without synchronization and any of those accesses uses a non-const member function of weak_ptr then a data race will occur unless all such access is performed through an instance of std::atomic<std::weak_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 used by std::weak_ptr and std::shared_ptr is thread-safe: different non-atomic std::weak_ptr objects can be accessed using mutable operations, such as operator= or reset, simultaneously by multiple threads, even when these instances are copies or otherwise share the same control block internally.
The type T may be an incomplete type.
Member types
| Member type | Definition |
value_type
|
std::weak_ptr<T> |
Member functions
All non-specialized std::atomic functions are also provided by this specialization, and no additional member functions.
atomic<weak_ptr<T>>::atomic
| constexpr atomic() noexcept = default; |
(1) | |
| atomic(std::weak_ptr<T> desired) noexcept; |
(2) | |
| atomic(const atomic&) = delete; |
(3) | |
weak_ptr<T> to default-constructed valueweak_ptr<T> to a copy of desired. As with any std::atomic type, initialization is not an atomic operation.atomic<weak_ptr<T>>::operator=
| void operator=(const atomic&) = delete; |
(1) | |
| void operator=(std::weak_ptr<T> desired) noexcept; |
(2) | |
atomic<weak_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<weak_ptr<T>>::store
| void store(std::weak_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::weak_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<weak_ptr<T>>::load
| std::weak_ptr<T> load(std::memory_order order = std::memory_order_seq_cst) const noexcept; |
||
Atomically returns a copy of the underlying std::weak_ptr<T>. Memory is ordered according to order. The behavior is undefined if order is std::memory_order_release or std::memory_order_acq_rel.
atomic<weak_ptr<T>>::operator std::weak_ptr<T>
| operator std::weak_ptr<T>() const noexcept; |
||
Equivalent to return load();
atomic<weak_ptr<T>>::exchange
| std::weak_ptr<T> exchange(std::weak_ptr<T> desired, std::memory_order order = std::memory_order_seq_cst) noexcept; |
||
Atomically replaces the underlying std::weak_ptr<T> with desired as if by p.swap(desired) where p is the underlying std::weak_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<weak_ptr<T>>::compare_exchange_weak, compare_exchange_strong
| bool compare_exchange_strong(std::weak_ptr<T>& expected, std::weak_ptr<T> desired, std::memory_order success, std::memory_order failure) noexcept; |
(1) | |
| bool compare_exchange_weak(std::weak_ptr<T>& expected, std::weak_ptr<T> desired, std::memory_order success, std::memory_order failure) noexcept; |
(2) | |
| bool compare_exchange_strong(std::weak_ptr<T>& expected, std::weak_ptr<T> desired, std::memory_order order = std::memory_order_seq_cst) noexcept; |
(3) | |
| bool compare_exchange_weak(std::weak_ptr<T>& expected, std::weak_ptr<T> desired, std::memory_order order = std::memory_order_seq_cst) noexcept; |
(4) | |
expected and shares ownership with it, or if both underlying and expected are empty, assigns from desired to the underlying std::weak_ptr<T>, returns true, and orders memory according to success, otherwise assigns from the underlying std::weak_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.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.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.
Member constants
The only standard std::atomic member constant is_always_lock_free is also provided by this specialization.
atomic<weak_ptr<T>>::is_always_lock_free
| static constexpr bool is_always_lock_free = /*implementation-defined*/; |
||
Example
| This section is incomplete Reason: no example |
See also
| (C++11) |
atomic class template and specializations for bool, integral, and pointer types (class template) |