View source for cpp/memory/weak ptr/atomic2

===Member functions===
All non-specialized {{lc|std::atomic}} functions are also provided by this specialization, and no additional member functions.

{{member|{{small|atomic<weak_ptr<T>>::}}atomic|2=
{{dcl begin}}
{{dcl|num=1|1=
constexpr atomic() noexcept = default;
}}
{{dcl|num=2|
atomic(std::weak_ptr<T> desired) noexcept;
}}
{{dcl|num=3|1=
atomic(const atomic&) = delete;
}}
{{dcl end}}
@1@ Initializes the underlying {{tt|weak_ptr<T>}} to default-constructed value.
@2@ Initializes the underlying {{tt|weak_ptr<T>}} to a copy of {{tt|desired}}. As with any {{lc|std::atomic}} type, initialization is not an atomic operation.
@3@ Atomic types are not copy/move constructible.
}}

{{member|{{small|atomic<weak_ptr<T>>::}}operator{{=}}|2=
{{dcl begin}}
{{dcl|num=1|1=
void operator=(const atomic&) = delete;
}}
{{dcl|num=2|1=
void operator=(std::weak_ptr<T> desired) noexcept;
}}
{{dcl end}}
@1@ Atomic types are not copy/move assignable.
@2@ Value assignment, equivalent to {{c|store(desired)}}.
}}

{{member|{{small|atomic<weak_ptr<T>>::}}is_lock_free|2=
{{ddcl|
bool is_lock_free() const noexcept;
}}
Returns true if the atomic operations on all objects of this type are lock-free, false otherwise.
}}

{{member|{{small|atomic<weak_ptr<T>>::}}store|2=
{{ddcl|1=
void store(std::weak_ptr<T> desired,
           std::memory_order order = std::memory_order_seq_cst) noexcept;
}}
Atomically replaces the value of {{c|*this}} with the value of {{tt|desired}} as if by {{c|p.swap(desired)}} where {{c|p}} is the underlying {{c|std::weak_ptr<T>}}. Memory is ordered according to {{tt|order}}. The behavior is undefined if {{tt|order}} is {{lc|std::memory_order_consume}}, {{lc|std::memory_order_acquire}}, or {{lc|std::memory_order_acq_rel}}.
}}

{{member|{{small|atomic<weak_ptr<T>>::}}load|2=
{{ddcl|1=
std::weak_ptr<T> load(std::memory_order order = std::memory_order_seq_cst) const noexcept;
}}
Atomically returns a copy of the underlying {{c|std::weak_ptr<T>}}. Memory is ordered according to {{tt|order}}. The behavior is undefined if {{tt|order}} is {{lc|std::memory_order_release}} or {{lc|std::memory_order_acq_rel}}.
}}

{{member|{{small|atomic<weak_ptr<T>>::}}operator std::weak_ptr<T>|2=
{{ddcl|
operator std::weak_ptr<T>() const noexcept;
}}
Equivalent to {{c|return load();}}.
}}

{{member|{{small|atomic<weak_ptr<T>>::}}exchange|2=
{{ddcl|1=
std::weak_ptr<T> exchange(std::weak_ptr<T> desired,
                          std::memory_order order = std::memory_order_seq_cst) noexcept;

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

{{member|{{small|atomic<weak_ptr<T>>::}}compare_exchange_weak, compare_exchange_strong|2=
{{dcl begin}}
{{dcl|num=1|
bool compare_exchange_strong(std::weak_ptr<T>& expected, std::weak_ptr<T> desired,
                             std::memory_order success, std::memory_order failure) noexcept;
}}
{{dcl|num=2|
bool compare_exchange_weak(std::weak_ptr<T>& expected, std::weak_ptr<T> desired,
                           std::memory_order success, std::memory_order failure) noexcept;
}}
{{dcl|num=3|1=
bool compare_exchange_strong(std::weak_ptr<T>& expected, std::weak_ptr<T> desired,
                             std::memory_order order = std::memory_order_seq_cst) noexcept;
}}
{{dcl|num=4|1=
bool compare_exchange_weak(std::weak_ptr<T>& expected, std::weak_ptr<T> desired,
                           std::memory_order order = std::memory_order_seq_cst) noexcept;
}}
{{dcl end}}
@1@ If the underlying {{c|std::weak_ptr<T>}} stores the same pointer value as {{tt|expected}} and shares ownership with it, or if both underlying and {{tt|expected}} are empty, assigns from {{tt|desired}} to the underlying {{c|std::weak_ptr<T>}}, returns {{c|true}}, and orders memory according to {{tt|success}}, otherwise assigns from the underlying {{c|std::weak_ptr<T>}} to {{tt|expected}}, returns {{c|false}}, and orders memory according to {{tt|failure}}. The behavior is undefined if {{tt|failure}} is {{lc|std::memory_order_release}} or {{lc|std::memory_order_acq_rel}}. On success, the operation is an atomic read-modify-write operation on {{c|*this}} and {{tt|expected}} is not accessed after the atomic update. On failure, the operation is an atomic load operation on {{c|*this}} and {{tt|expected}} is updated with the existing value read from the atomic object. This update to {{tt|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 {{v|1}}, but may also fail spuriously.
@3@ Equivalent to: {{c|return compare_exchange_strong(expected, desired, order, fail_order);}}, where {{tt|fail_order}} is the same as {{tt|order}} except that {{lc|std::memory_order_acq_rel}} is replaced by {{lc|std::memory_order_acquire}} and {{lc|std::memory_order_release}} is replaced by {{lc|std::memory_order_relaxed}}.
@4@ Equivalent to: {{c|return compare_exchange_weak(expected, desired, order, fail_order);}}, where {{tt|fail_order}} is the same as {{tt|order}} except that {{lc|std::memory_order_acq_rel}} is replaced by {{lc|std::memory_order_acquire}} and {{lc|std::memory_order_release}} is replaced by {{lc|std::memory_order_relaxed}}.
}}

{{member|{{small|atomic<weak_ptr<T>>::}}wait|2=
{{ddcl|1=
void wait(std::weak_ptr<T> old
          std::memory_order order = std::memory_order_seq_cst) const noexcept;
}}

Performs an atomic waiting operation.

Compares {{c|load(order)}} with {{tt|old}} and if they are equivalent then blocks until {{c|*this}} is notified by {{tt|notify_one()}} or {{tt|notify_all()}}. This is repeated until {{c|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 {{tt|order}}. The behavior is undefined if {{tt|order}} is {{lc|std::memory_order_release}} or {{lc|std::memory_order_acq_rel}}.

Notes: two {{lc|std::weak_ptr}}s are equivalent if they store the same pointer and either share ownership or are both empty.
}}

{{member|{{small|atomic<weak_ptr<T>>::}}notify_one|2=
{{ddcl|1=
void notify_one() noexcept;
}}

Performs an atomic notifying operation.

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

{{member|{{small|atomic<weak_ptr<T>>::}}notify_all|2=
{{ddcl|1=
void notify_all() noexcept;
}}

Performs an atomic notifying operation.

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