std::atomic_ref::compare_exchange_weak,std::atomic_ref::compare_exchange_strong(3)

NAME
std::atomic_ref::compare_exchange_weak,std::atomic_ref::compare_exchange_strong - std::atomic_ref::compare_exchange_weak,std::atomic_ref::compare_exchange_strong

Synopsis
   bool compare_exchange_weak( T& expected, T desired,
   std::memory_order success, (1) (since C++20)
   std::memory_order failure ) const noexcept;
   bool compare_exchange_weak( T& expected, T desired,
   std::memory_order order = (2) (since C++20)
   std::memory_order_seq_cst ) const noexcept;
   bool compare_exchange_strong( T& expected, T desired,
   std::memory_order success, (3) (since C++20)
   std::memory_order failure ) const noexcept;
   bool compare_exchange_strong( T& expected, T desired,
   std::memory_order order = (4) (since C++20)
   std::memory_order_seq_cst ) const noexcept;
   Atomically compares the value representation of the referenced object with that of
   expected, and if those are bitwise-equal, replaces the former with desired (performs
   a read-modify-write operation). Otherwise, loads the actual value stored in the
   referenced object into expected (performs a load operation).
   The memory models for the read-modify-write and load operations are success and
   failure respectively. In the (2) and (4) versions order is used for both
   read-modify-write and load operations, except that std::memory_order_acquire and
   std::memory_order_relaxed are used for the load operation if order ==
   std::memory_order_acq_rel, or order == std::memory_order_release respectively.

Parameters
   expected - reference to the value expected to be found in the object referenced by
              the atomic_ref object
   desired - the value to store in the referenced object if it is as expected
   success - the memory synchronization ordering for the read-modify-write operation
              if the comparison succeeds. All values are permitted.
              the memory synchronization ordering for the load operation if the
   failure - comparison fails. Cannot be std::memory_order_release or
              std::memory_order_acq_rel
   order - the memory synchronization ordering for both operations

Return value
   true if the referenced object was successfully changed, false otherwise.

Notes
   The comparison and copying are bitwise (similar to std::memcmp and std::memcpy); no
   constructor, assignment operator, or comparison operator are used.
   The weak forms (1-2) of the functions are allowed to fail spuriously, that is, act
   as if *this != expected even if they are equal. When a compare-and-exchange is in a
   loop, the weak version will yield better performance on some platforms.
   When a weak compare-and-exchange would require a loop and a strong one would not,
   the strong one is preferable unless the object representation of T may include trap
   bits, or offers multiple object representations for the same value (e.g.
   floating-point NaN). In those cases, weak compare-and-exchange typically works
   because it quickly converges on some stable object representation.
   For a union with bits that participate in the value representations of some members
   but not the others, compare-and-exchange might always fail because such padding bits
   have indeterminate values when they do not participate in the value representation
   of the active member.
   Padding bits that never participate in an object's value representation are ignored.

Example
    This section is incomplete
    Reason: no example