Atomically compare the value to an expected value, and store a new
value if the values are equal. If the values were not equal, update
the expected value with the value read. Additionally, this may fail
spuriously (and return false)
even if the values were equal, if the value could not be updated
atomically.
bool compare_exchange_weak( integral-type& expected, integral-type new_value, memory_order order = std::memory_order_seq_cst) volatile; bool compare_exchange_weak( integral-type& expected, integral-type new_value, memory_order success_order, memory_order failure_order) volatile;
failure_order
shall not be std::memory_order_release
or std::memory_order_acq_rel.
Atomically compares expected
to the value stored in *this and stores new_value in *this
if equal, otherwise updates expected
to the value read.
true if the existing
value of *this
was equal to expected
and new_value
was successfully stored in *this, false
otherwise.
Nothing.
The 3-parameter overload is equivalent to the 4-parameter overload
with success_order==order,
and failure_order==order,
except that if order
is std::memory_order_acq_rel, then
failure_order
is std::memory_order_acquire, and
if order is
std::memory_order_release then
failure_order
is std::memory_order_relaxed.
This is an atomic read-modify-write operation for the memory
location comprising *this if the result is true, with memory ordering
success_order,
otherwise it is an atomic load operation for the memory location
comprising *this
with memory ordering failure_order.
#include <atomic>