Namespaces
Variants
Views
Actions

std::atomic_compare_exchange_weak, std::atomic_compare_exchange_strong, std::atomic_compare_exchange_weak_explicit, std::atomic_compare_exchange_strong_explicit

From cppreference.com
< cpp‎ | atomic
Revision as of 10:49, 20 April 2013 by 84.50.136.238 (Talk)

Template:ddcl list begin <tr class="t-dsc-header">

<td>
Defined in header <atomic>
</td>

<td></td> <td></td> <tr class="t-dcl ">

<td >
template< class T >

bool atomic_compare_exchange_weak( std::atomic<T>* obj,
                                   T* expected, T desired );
template< class T >
bool atomic_compare_exchange_weak( volatile std::atomic<T>* obj,

                                   T* expected, T desired );
</td>

<td > (1) </td> <td > (since C++11) </td> </tr> <tr class="t-dcl ">

<td >
template< class T >

bool atomic_compare_exchange_strong( std::atomic<T>* obj,
                                     T* expected, T desired );
template< class T >
bool atomic_compare_exchange_strong( volatile std::atomic<T>* obj,

                                     T* expected, T desired );
</td>

<td > (2) </td> <td > (since C++11) </td> </tr> <tr class="t-dcl ">

<td >
template< class T >

bool atomic_compare_exchange_weak_explicit( std::atomic<T>* obj,
                                            T* expected, T desired,
                                            std::memory_order succ,
                                            std::memory_order fail );
template< class T >
bool atomic_compare_exchange_weak_explicit( volatile std::atomic<T>* obj,
                                            T* expected, T desired,
                                            std::memory_order succ,

                                            std::memory_order fail );
</td>

<td > (3) </td> <td > (since C++11) </td> </tr> <tr class="t-dcl ">

<td >
template< class T >

bool atomic_compare_exchange_strong_explicit( std::atomic<T>* obj,
                                              T* expected, T desired,
                                              std::memory_order succ,
                                              std::memory_order fail );
template< class T >
bool atomic_compare_exchange_strong_explicit( volatile std::atomic<T>* obj,
                                              T* expected, T desired,
                                              std::memory_order succ,

                                              std::memory_order fail );
</td>

<td > (4) </td> <td > (since C++11) </td> </tr> Template:ddcl list end

Atomically compares the value pointed to by obj with the value pointed to by expected, and if those are equal, replaces the former with desired (performs read-modify-write operation). Otherwise, loads the actual value pointed to by obj into *expected (performs load operation).

The memory models for the read-modify-write and load operations are succ and fail respectively. The (1-2) versions use std::memory_order_seq_cst by default.

The weak forms ((1) and (3)) of the functions are allowed to fail spuriously, that is, act as if *obj != *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.

These functions are defined in terms of member functions of std::atomic:

1) obj->compare_exchange_weak(exp, desr)
2) obj->compare_exchange_strong(exp, desr)
3) obj->compare_exchange_weak(exp, desr, succ, fail)
4) obj->compare_exchange_strong(exp, desr, succ, fail)

Contents

Parameters

obj - pointer to the atomic object to test and modify
expected - pointer to the value expected to be found in the atomic object
desired - the value to store in the atomic object if it is as expected
succ - the memory sycnhronization ordering for the read-modify-write operation if the comparison succeeds. All values are permitted.
fail - the memory sycnhronization ordering for the load operation if the comparison fails. Cannot be std::memory_order_release or std::memory_order_acq_rel and cannot specify stronger ordering than succ

Return value

The result of the comparison: true if *obj was equal to *exp, false otherwise.

Exceptions

noexcept specification:  
noexcept
  

Example

See also

Template:cpp/atomic/atomic/dcl list compare exchangeTemplate:cpp/atomic/dcl list atomic exchange
specializes atomic operations for std::shared_ptr
(function template)
C documentation for atomic_compare_exchange, atomic_compare_exchange_explicit