atomic

This header is part of the atomic operations library.

Classes

(C++11)
atomic class template and specializations for bool, integral, and pointer types
(class template)
(C++11)
the lock-free boolean atomic type
(class)
(C++11)
defines memory ordering constraints for the given atomic operation
(typedef)

Typedefs

std::atomic_bool std::atomic<bool>
std::atomic_char std::atomic<char>
std::atomic_schar std::atomic<signed char>
std::atomic_uchar std::atomic<unsigned char>
std::atomic_short std::atomic<short>
std::atomic_ushort std::atomic<unsigned short>
std::atomic_int std::atomic<int>
std::atomic_uint std::atomic<unsigned int>
std::atomic_long std::atomic<long>
std::atomic_ulong std::atomic<unsigned long>
std::atomic_llong std::atomic<long long>
std::atomic_ullong std::atomic<unsigned long long>
std::atomic_char16_t std::atomic<char16_t>
std::atomic_char32_t std::atomic<char32_t>
std::atomic_wchar_t std::atomic<wchar_t>
std::atomic_int_least8_t std::atomic<int_least8_t>
std::atomic_uint_least8_t std::atomic<uint_least8_t>
std::atomic_int_least16_t std::atomic<int_least16_t>
std::atomic_uint_least16_t std::atomic<uint_least16_t>
std::atomic_int_least32_t std::atomic<int_least32_t>
std::atomic_uint_least32_t std::atomic<uint_least32_t>
std::atomic_int_least64_t std::atomic<int_least64_t>
std::atomic_uint_least64_t std::atomic<uint_least64_t>
std::atomic_int_fast8_t std::atomic<int_fast8_t>
std::atomic_uint_fast8_t std::atomic<uint_fast8_t>
std::atomic_int_fast16_t std::atomic<int_fast16_t>
std::atomic_uint_fast16_t std::atomic<uint_fast16_t>
std::atomic_int_fast32_t std::atomic<int_fast32_t>
std::atomic_uint_fast32_t std::atomic<uint_fast32_t>
std::atomic_int_fast64_t std::atomic<int_fast64_t>
std::atomic_uint_fast64_t std::atomic<uint_fast64_t>
std::atomic_intptr_t std::atomic<intptr_t>
std::atomic_uintptr_t std::atomic<uintptr_t>
std::atomic_size_t std::atomic<size_t>
std::atomic_ptrdiff_t std::atomic<ptrdiff_t>
std::atomic_intmax_t std::atomic<intmax_t>
std::atomic_uintmax_t std::atomic<uintmax_t>

Functions

checks if the atomic type's operations are lock-free
(function template)
atomically replaces the value of the atomic object with a non-atomic argument
(function template)
atomically obtains the value stored in an atomic object
(function template)
atomically replaces the value of the atomic object with non-atomic argument and returns the old value of the atomic
(function template)
atomically compares the value of the atomic object with non-atomic argument and performs atomic exchange if equal or atomic load if not
(function template)
adds a non-atomic value to an atomic object and obtains the previous value of the atomic
(function template)
subtracts a non-atomic value from an atomic object and obtains the previous value of the atomic
(function template)
replaces the atomic object with the result of logical AND with a non-atomic argument and obtains the previous value of the atomic
(function template)
replaces the atomic object with the result of logical OR with a non-atomic argument and obtains the previous value of the atomic
(function template)
replaces the atomic object with the result of logical XOR with a non-atomic argument and obtains the previous value of the atomic
(function template)
atomically sets the flag to true and returns its previous value
(function)
atomically sets the value of the flag to false
(function)
(C++11)
non-atomic initialization of a default-constructed atomic object
(function template)
removes the specified object from the std::memory_order_consume dependency tree
(function template)
generic memory order-dependent fence synchronization primitive
(function)
fence between a thread and a signal handler executed in the same thread
(function)

Preprocessor macros

constant initialization of an atomic variable of static storage duration
(function macro)
initializes an std::atomic_flag to false
(macro constant)

Synopsis

namespace std {
    typedef enum memory_order {
        memory_order_relaxed,
        memory_order_consume,
        memory_order_acquire,
        memory_order_release,
        memory_order_acq_rel,
        memory_order_seq_cst
    } memory_order;
 
    template <class T>
    T kill_dependency(T y) noexcept;
 
    // lock-free property
    #define ATOMIC_BOOL_LOCK_FREE /*unspecified*/
    #define ATOMIC_CHAR_LOCK_FREE /*unspecified*/
    #define ATOMIC_CHAR16_T_LOCK_FREE /*unspecified*/
    #define ATOMIC_CHAR32_T_LOCK_FREE /*unspecified*/
    #define ATOMIC_WCHAR_T_LOCK_FREE /*unspecified*/
    #define ATOMIC_SHORT_LOCK_FREE /*unspecified*/
    #define ATOMIC_INT_LOCK_FREE /*unspecified*/
    #define ATOMIC_LONG_LOCK_FREE /*unspecified*/
    #define ATOMIC_LLONG_LOCK_FREE /*unspecified*/
    #define ATOMIC_POINTER_LOCK_FREE /*unspecified*/
 
    // generic atomic type
    template<class T> struct atomic;
    // specialization for integral types
    template<> struct atomic</*integral*/>;
    // specialization for pointers
    template<class T> struct atomic<T*>;
 
    // named typedefs
    typedef atomic<bool> atomic_bool;
    typedef atomic<char> atomic_char;
    typedef atomic<signed char> atomic_schar;
    typedef atomic<unsigned char> atomic_uchar;
    typedef atomic<short> atomic_short;
    typedef atomic<unsigned short> atomic_ushort;
    typedef atomic<int> atomic_int;
    typedef atomic<unsigned int> atomic_uint;
    typedef atomic<long> atomic_long;
    typedef atomic<unsigned long> atomic_ulong;
    typedef atomic<long long> atomic_llong;
    typedef atomic<unsigned long long> atomic_ullong;
    typedef atomic<char16_t> atomic_char16_t;
    typedef atomic<char32_t> atomic_char32_t;
    typedef atomic<wchar_t> atomic_wchar_t;
    typedef atomic<int_least8_t> atomic_int_least8_t;
    typedef atomic<uint_least8_t> atomic_uint_least8_t;
    typedef atomic<int_least16_t> atomic_int_least16_t;
    typedef atomic<uint_least16_t> atomic_uint_least16_t;
    typedef atomic<int_least32_t> atomic_int_least32_t;
    typedef atomic<uint_least32_t> atomic_uint_least32_t;
    typedef atomic<int_least64_t> atomic_int_least64_t;
    typedef atomic<uint_least64_t> atomic_uint_least64_t;
    typedef atomic<int_fast8_t> atomic_int_fast8_t;
    typedef atomic<uint_fast8_t> atomic_uint_fast8_t;
    typedef atomic<int_fast16_t> atomic_int_fast16_t;
    typedef atomic<uint_fast16_t> atomic_uint_fast16_t;
    typedef atomic<int_fast32_t> atomic_int_fast32_t;
    typedef atomic<uint_fast32_t> atomic_uint_fast32_t;
    typedef atomic<int_fast64_t> atomic_int_fast64_t;
    typedef atomic<uint_fast64_t> atomic_uint_fast64_t;
    typedef atomic<intptr_t> atomic_intptr_t;
    typedef atomic<uintptr_t> atomic_uintptr_t;
    typedef atomic<size_t> atomic_size_t;
    typedef atomic<ptrdiff_t> atomic_ptrdiff_t;
    typedef atomic<intmax_t> atomic_intmax_t;
    typedef atomic<uintmax_t> atomic_uintmax_t;
 
    // general operations on atomic types
    // /*atomic-type*/ is either atomic<T> or one of the typedefs
    // (if it's atomic<T>, then template<class T> is implied)
    bool atomic_is_lock_free(const volatile /*atomic-type*/ *) noexcept;
    bool atomic_is_lock_free(const /*atomic-type*/ *) noexcept;
    void atomic_init(volatile /*atomic-type*/ *, T) noexcept;
    void atomic_init(/*atomic-type*/ *, T) noexcept;
    void atomic_store(volatile /*atomic-type*/ *, T) noexcept;
    void atomic_store(/*atomic-type*/ *, T) noexcept;
    void atomic_store_explicit(volatile /*atomic-type*/ *, T, memory_order) noexcept;
    void atomic_store_explicit(/*atomic-type*/ *, T, memory_order) noexcept;
    T atomic_load(const volatile /*atomic-type*/ *) noexcept;
    T atomic_load(const /*atomic-type*/ *) noexcept;
    T atomic_load_explicit(const volatile /*atomic-type*/ *, memory_order) noexcept;
    T atomic_load_explicit(const /*atomic-type*/ *, memory_order) noexcept;
    T atomic_exchange(volatile /*atomic-type*/ *, T) noexcept;
    T atomic_exchange(/*atomic-type*/ *, T) noexcept;
    T atomic_exchange_explicit(volatile /*atomic-type*/ *, T, memory_order) noexcept;
    T atomic_exchange_explicit(/*atomic-type*/ *, T, memory_order) noexcept;
    bool atomic_compare_exchange_weak(volatile /*atomic-type*/ *, T*, T) noexcept;
    bool atomic_compare_exchange_weak(/*atomic-type*/ *, T*, T) noexcept;
    bool atomic_compare_exchange_strong(volatile /*atomic-type*/ *, T*, T) noexcept;
    bool atomic_compare_exchange_strong(/*atomic-type*/ *, T*, T) noexcept;
    bool atomic_compare_exchange_weak_explicit(volatile /*atomic-type*/ *, T*, T,
                                               memory_order, memory_order) noexcept;
    bool atomic_compare_exchange_weak_explicit(/*atomic-type*/ *, T*, T.
                                               memory_order, memory_order) noexcept;
    bool atomic_compare)exchange_strong_explicit(volatile /*atomic-type*/ *, T*, T,
                                                 memory_order, memory_order) noexcept;
    bool atomic_compare_exchange_strong_explicit(/*atomic-type*/ *, T*, T,
                                                 memory_order, memory_order) noexcept;
 
    // templated operations on atomic types (declared, but not defined)
    template <class T>
    T atomic_fetch_add(volatile atomic<T>*, T) noexcept;
    template <class T>
    T atomic_fetch_add(atomic<T>*, T) noexcept;
    template <class T>
    T atomic_fetch_add_explicit(volatile atomic<T>*, T, memory_order) noexcept;
    template <class T>
    T atomic_fetch_add_explicit(atomic<T>*, T, memory_order) noexcept;
    template <class T>
    T atomic_fetch_sub(volatile atomic<T>*, T) noexcept;
    template <class T>
    T atomic_fetch_sub(atomic<T>*, T) noexcept;
    template <class T>
    T atomic_fetch_sub_explicit(volatile atomic<T>*, T, memory_order) noexcept;
    template <class T>
    T atomic_fetch_sub_explicit(atomic<T>*, T, memory_order) noexcept;
    template <class T>
    T atomic_fetch_and(volatile atomic<T>*, T) noexcept;
    template <class T>
    T atomic_fetch_and(atomic<T>*, T) noexcept;
    template <class T>
    T atomic_fetch_and_explicit(volatile atomic<T>*, T, memory_order) noexcept;
    template <class T>
    T atomic_fetch_and_explicit(atomic<T>*, T, memory_order) noexcept;
    template <class T>
    T atomic_fetch_or(volatile atomic<T>*, T) noexcept;
    template <class T>
    T atomic_fetch_or(atomic<T>*, T) noexcept;
    template <class T>
    T atomic_fetch_or_explicit(volatile atomic<T>*, T, memory_order) noexcept;
    template <class T>
    T atomic_fetch_or_explicit(atomic<T>*, T, memory_order) noexcept;
    template <class T>
    T atomic_fetch_xor(volatile atomic<T>*, T) noexcept;
    template <class T>
    T atomic_fetch_xor(atomic<T>*, T) noexcept;
    template <class T>
    T atomic_fetch_xor_explicit(volatile atomic<T>*, T, memory_order) noexcept;
    template <class T>
    T atomic_fetch_xor_explicit(atomic<T>*, T, memory_order) noexcept;
 
    // arithmetic operations on atomic types
    // /*atomic-integral*/ is either atomic<T> or one of the typedefs
    // (if it's atomic<T>, then template<> is implied)
    /*integral*/ atomic_fetch_add(volatile /*atomic-integral*/ *,
                                  /*integral*/ ) noexcept;
    /*integral*/ atomic_fetch_add(/*atomic-integral*/ *,
                                  /*integral*/ ) noexcept;
    /*integral*/ atomic_fetch_add_explicit(volatile /*atomic-integral*/ *,
                                           /*integral*/,
                                            memory_order) noexcept;
    /*integral*/ atomic_fetch_add_explicit(/*atomic-integral*/ *,
                                           /*integral*/,
                                           memory_order) noexcept;
    /*integral*/ atomic_fetch_sub(volatile /*atomic-integral*/ *,
                                  /*integral*/ ) noexcept;
    /*integral*/ atomic_fetch_sub(/*atomic-integral*/ *,
                                  /*integral*/ ) noexcept;
    /*integral*/ atomic_fetch_sub_explicit(volatile /*atomic-integral*/ *,
                                           /*integral*/ ,
                                           memory_order) noexcept;
    /*integral*/ atomic_fetch_sub_explicit(/*atomic-integral*/ *,
                                           /*integral*/ ,
                                           memory_order) noexcept;
    /*integral*/ atomic_fetch_and(volatile /*atomic-integral*/ *,
                                  /*integral*/ ) noexcept;
    /*integral*/ atomic_fetch_and(/*atomic-integral*/ *,
                                  /*integral*/ ) noexcept;
    /*integral*/ atomic_fetch_and_explicit(volatile /*atomic-integral*/ *,
                                           /*integral*/ ,
                                           memory_order) noexcept;
    /*integral*/ atomic_fetch_and_explicit(/*atomic-integral*/ *,
                                           /*integral*/ ,
                                           memory_order) noexcept;
    /*integral*/ atomic_fetch_or(volatile /*atomic-integral*/ *,
                                 /*integral*/ ) noexcept;
    /*integral*/ atomic_fetch_or(/*atomic-integral*/ *,
                                 /*integral*/ ) noexcept;
    /*integral*/ atomic_fetch_or_explicit(volatile /*atomic-integral*/ *,
                                          /*integral*/ ,
                                          memory_order) noexcept;
    /*integral*/ atomic_fetch_or_explicit(/*atomic-integral*/ *,
                                          /*integral*/ ,
                                          memory_order) noexcept;
    /*integral*/ atomic_fetch_xor(volatile /*atomic-integral*/ *,
                                  /*integral*/ ) noexcept;
    /*integral*/ atomic_fetch_xor(/*atomic-integral*/ *,
                                  /*integral*/ ) noexcept;
    /*integral*/ atomic_fetch_xor_explicit(volatile /*atomic-integral*/ *,
                                           /*integral*/ , memory_order) noexcept;
    /*integral*/ atomic_fetch_xor_explicit(/*atomic-integral*/ *,
                                           /*integral*/ ,
                                           memory_order) noexcept;
 
    // partial specializations for pointers
    template <class T>
    T* atomic_fetch_add(volatile atomic<T*>*, ptrdiff_t) noexcept;
    template <class T>
    T* atomic_fetch_add(atomic<T*>*, ptrdiff_t) noexcept;
    template <class T>
    T* atomic_fetch_add_explicit(volatile atomic<T*>*,
                                 ptrdiff_t, memory_order) noexcept;
    template <class T>
    T* atomic_fetch_add_explicit(atomic<T*>*, ptrdiff_t, memory_order) noexcept;
    template <class T>
    T* atomic_fetch_sub(volatile atomic<T*>*, ptrdiff_t) noexcept;
    template <class T>
    T* atomic_fetch_sub(atomic<T*>*, ptrdiff_t) noexcept;
    template <class T>
    T* atomic_fetch_sub_explicit(volatile atomic<T*>*,
                                 ptrdiff_t, memory_order) noexcept;
    template <class T>
    T* atomic_fetch_sub_explicit(atomic<T*>*, ptrdiff_t, memory_order) noexcept;
 
    // initialization
    #define ATOMIC_VAR_INIT(value) /*see description*/
 
    // flag type and operations
    struct atomic_flag;
 
    bool atomic_flag_test_and_set(volatile atomic_flag*) noexcept;
    bool atomic_flag_test_and_set(atomic_flag*) noexcept;
    bool atomic_flag_test_and_set_explicit(volatile atomic_flag*,
                                           memory_order) noexcept;
    bool atomic_flag_test_and_set_explicit(atomic_flag*, memory_order) noexcept;
    void atomic_flag_clear(volatile atomic_flag*) noexcept;
    void atomic_flag_clear(atomic_flag*) noexcept;
    void atomic_flag_clear_explicit(volatile atomic_flag*, memory_order) noexcept;
    void atomic_flag_clear_explicit(atomic_flag*, memory_order) noexcept;
 
    #define ATOMIC_FLAG_INIT /*see description*/
 
    // fences
    extern "C" void atomic_thread_fence(memory_order) noexcept;
    extern "C" void atomic_signal_fence(memory_order) noexcept;

Class std::atomic

template <class T> struct atomic {
    bool is_lock_free() const volatile noexcept;
    bool is_lock_free() const noexcept;
    void store(T, memory_order = memory_order_seq_cst) volatile noexcept;
    void store(T, memory_order = memory_order_seq_cst) noexcept;
    T load(memory_order = memory_order_seq_cst) const volatile noexcept;
    T load(memory_order = memory_order_seq_cst) const noexcept;
    operator T() const volatile noexcept;
    operator T() const noexcept;
    T exchange(T, memory_order = memory_order_seq_cst) volatile noexcept;
    T exchange(T, memory_order = memory_order_seq_cst) noexcept;
    bool compare_exchange_weak(T&, T,
                               memory_order, memory_order) volatile noexcept;
    bool compare_exchange_weak(T&, T,
                               memory_order, memory_order) noexcept;
    bool compare_exchange_strong(T&, T,
                                 memory_order, memory_order) volatile noexcept;
    bool compare_exchange_strong(T&, T,
                                 memory_order, memory_order) noexcept;
    bool compare_exchange_weak(T&, T,
                               memory_order = memory_order_seq_cst) volatile noexcept;
    bool compare_exchange_weak(T&, T,
                               memory_order = memory_order_seq_cst) noexcept;
    bool compare_exchange_strong(T&, T,
                                 memory_order = memory_order_seq_cst) volatile noexcept;
    bool compare_exchange_strong(T&, T,
                                 memory_order = memory_order_seq_cst) noexcept;
 
    atomic() noexcept = default;
    constexpr atomic(T) noexcept;
    atomic(const atomic&) = delete;
    atomic& operator=(const atomic&) = delete;
    atomic& operator=(const atomic&) volatile = delete;
    T operator=(T) volatile noexcept;
    T operator=(T) noexcept;
};

Specialization of std::atomic for integral types

template<> struct atomic</*integral*/> {
    bool is_lock_free() const volatile noexcept;
    bool is_lock_free() const noexcept;
    void store(/*integral*/,
               memory_order = memory_order_seq_cst) volatile noexcept;
    void store(/*integral*/,
               memory_order = memory_order_seq_cst) noexcept;
    /*integral*/ load(memory_order = memory_order_seq_cst) const volatile noexcept;
    /*integral*/ load(memory_order = memory_order_seq_cst) const noexcept;
    operator /*integral*/() const volatile noexcept;
    operator /*integral*/() const noexcept;
    /*integral*/ exchange(/*integral*/,
                          memory_order = memory_order_seq_cst) volatile noexcept;
    /*integral*/ exchange(/*integral*/,
                          memory_order = memory_order_seq_cst) noexcept;
    bool compare_exchange_weak(/*integral*/&, /*integral*/,
                               memory_order, memory_order) volatile noexcept;
    bool compare_exchange_weak(/*integral*/&, /*integral*/,
                               memory_order, memory_order) noexcept;
    bool compare_exchange_strong(/*integral*/&, /*integral*/,
                                 memory_order, memory_order) volatile noexcept;
    bool compare_exchange_strong(/*integral*/&, /*integral*/,
                                 memory_order, memory_order) noexcept;
    bool compare_exchange_weak(/*integral*/&, /*integral*/,
                               memory_order = memory_order_seq_cst) volatile noexcept;
    bool compare_exchange_weak(/*integral*/&, /*integral*/,
                               memory_order = memory_order_seq_cst) noexcept;
    bool compare_exchange_strong(/*integral*/&, /*integral*/,
                                 memory_order = memory_order_seq_cst) volatile noexcept;
    bool compare_exchange_strong(/*integral*/&, /*integral*/,
                                 memory_order = memory_order_seq_cst) noexcept;
    /*integral*/ fetch_add(/*integral*/,
                           memory_order = memory_order_seq_cst) volatile noexcept;
    /*integral*/ fetch_add(/*integral*/,
                           memory_order = memory_order_seq_cst) noexcept;
    /*integral*/ fetch_sub(/*integral*/,
                           memory_order = memory_order_seq_cst) volatile noexcept;
    /*integral*/ fetch_sub(/*integral*/,
                           memory_order = memory_order_seq_cst) noexcept;
    /*integral*/ fetch_and(/*integral*/,
                           memory_order = memory_order_seq_cst) volatile noexcept;
    /*integral*/ fetch_and(/*integral*/,
                           memory_order = memory_order_seq_cst) noexcept;
    /*integral*/ fetch_or(/*integral*/,
                          memory_order = memory_order_seq_cst) volatile noexcept;
    /*integral*/ fetch_or(/*integral*/,
                          memory_order = memory_order_seq_cst) noexcept;
    /*integral*/ fetch_xor(/*integral*/,
                           memory_order = memory_order_seq_cst) volatile noexcept;
    /*integral*/ fetch_xor(/*integral*/,
                           memory_order = memory_order_seq_cst) noexcept;
 
    atomic() noexcept = default;
    constexpr atomic(/*integral*/) noexcept;
    atomic(const atomic&) = delete;
    atomic& operator=(const atomic&) = delete;
    atomic& operator=(const atomic&) volatile = delete;
    /*integral*/ operator=(/*integral*/) volatile noexcept;
    /*integral*/ operator=(/*integral*/) noexcept;
    /*integral*/ operator++(int) volatile noexcept;
    /*integral*/ operator++(int) noexcept;
    /*integral*/ operator--(int) volatile noexcept;
    /*integral*/ operator--(int) noexcept;
    /*integral*/ operator++() volatile noexcept;
    /*integral*/ operator++() noexcept;
    /*integral*/ operator--() volatile noexcept;
    /*integral*/ operator--() noexcept;
    /*integral*/ operator+=(/*integral*/) volatile noexcept;
    /*integral*/ operator+=(/*integral*/) noexcept;
    /*integral*/ operator-=(/*integral*/) volatile noexcept;
    /*integral*/ operator-=(/*integral*/) noexcept;
    /*integral*/ operator&=(/*integral*/) volatile noexcept;
    /*integral*/ operator&=(/*integral*/) noexcept;
    /*integral*/ operator|=(/*integral*/) volatile noexcept;
    /*integral*/ operator|=(/*integral*/) noexcept;
    /*integral*/ operator^=(/*integral*/) volatile noexcept;
    /*integral*/ operator^=(/*integral*/) noexcept;
};

Specialization of std::atomic for pointer types

template <class T> struct atomic<T*> {
    bool is_lock_free() const volatile noexcept;
    bool is_lock_free() const noexcept;
    void store(T*, memory_order = memory_order_seq_cst) volatile noexcept;
    void store(T*, memory_order = memory_order_seq_cst) noexcept;
    T* load(memory_order = memory_order_seq_cst) const volatile noexcept;
    T* load(memory_order = memory_order_seq_cst) const noexcept;
    operator T*() const volatile noexcept;
    operator T*() const noexcept;
    T* exchange(T*, memory_order = memory_order_seq_cst) volatile noexcept;
    T* exchange(T*, memory_order = memory_order_seq_cst) noexcept;
    bool compare_exchange_weak(T*&, T*, memory_order, memory_order) volatile noexcept;
    bool compare_exchange_weak(T*&, T*, memory_order, memory_order) noexcept;
    bool compare_exchange_strong(T*&, T*, memory_order, memory_order) volatile noexcept;
    bool compare_exchange_strong(T*&, T*, memory_order, memory_order) noexcept;
    bool compare_exchange_weak(T*&, T*,
                               memory_order = memory_order_seq_cst) volatile noexcept;
    bool compare_exchange_weak(T*&, T*,
                               memory_order = memory_order_seq_cst) noexcept;
    bool compare_exchange_strong(T*&, T*,
                                 memory_order = memory_order_seq_cst) volatile noexcept;
    bool compare_exchange_strong(T*&, T*,
                                 memory_order = memory_order_seq_cst) noexcept;
    T* fetch_add(ptrdiff_t, memory_order = memory_order_seq_cst) volatile noexcept;
    T* fetch_add(ptrdiff_t, memory_order = memory_order_seq_cst) noexcept;
    T* fetch_sub(ptrdiff_t, memory_order = memory_order_seq_cst) volatile noexcept;
    T* fetch_sub(ptrdiff_t, memory_order = memory_order_seq_cst) noexcept;
 
    atomic() noexcept = default;
    constexpr atomic(T*) noexcept;
    atomic(const atomic&) = delete;
    atomic& operator=(const atomic&) = delete;
    atomic& operator=(const atomic&) volatile = delete;
    T* operator=(T*) volatile noexcept;
    T* operator=(T*) noexcept;
    T* operator++(int) volatile noexcept;
    T* operator++(int) noexcept;
    T* operator--(int) volatile noexcept;
    T* operator--(int) noexcept;
    T* operator++() volatile noexcept;
    T* operator++() noexcept;
    T* operator--() volatile noexcept;
    T* operator--() noexcept;
    T* operator+=(ptrdiff_t) volatile noexcept;
    T* operator+=(ptrdiff_t) noexcept;
    T* operator-=(ptrdiff_t) volatile noexcept;
    T* operator-=(ptrdiff_t) noexcept;
};

Class std::atomic_flag

typedef struct atomic_flag {
    bool test_and_set(memory_order = memory_order_seq_cst) volatile noexcept;
    bool test_and_set(memory_order = memory_order_seq_cst) noexcept;
    void clear(memory_order = memory_order_seq_cst) volatile noexcept;
    void clear(memory_order = memory_order_seq_cst) noexcept;
    atomic_flag() noexcept = default;
    atomic_flag(const atomic_flag&) = delete;
    atomic_flag& operator=(const atomic_flag&) = delete;
    atomic_flag& operator=(const atomic_flag&) volatile = delete;
} atomic_flag;
doc_CPP
2016-10-11 09:57:35
Comments
Leave a Comment

Please login to continue.