Namespaces
Variants
Views
Actions

Standard library header <atomic>

From cppreference.com
< cpp‎ | header
Revision as of 20:28, 5 August 2013 by Cubbi (Talk | contribs)

(diff) ← Older revision | Latest revision (diff) | Newer revision → (diff)

This header is part of the atomic operations library.

Contents

Classes

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

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) [edit]
atomically replaces the value of the atomic object with a non-atomic argument
(function template) [edit]
atomically obtains the value stored in an atomic object
(function template) [edit]
atomically replaces the value of the atomic object with non-atomic argument and returns the old value of the atomic
(function template) [edit]
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) [edit]
adds a non-atomic value to an atomic object and obtains the previous value of the atomic
(function template) [edit]
subtracts a non-atomic value from an atomic object and obtains the previous value of the atomic
(function template) [edit]
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) [edit]
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) [edit]
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) [edit]
atomically sets the flag to true and returns its previous value
(function) [edit]
atomically sets the value of the flag to false
(function) [edit]
non-atomic initialization of a default-constructed atomic object
(function template) [edit]
removes the specified object from the std::memory_order_consume dependency tree
(function template) [edit]
generic memory order-dependent fence synchronization primitive
(function) [edit]
fence between a thread and a signal handler executed in the same thread
(function) [edit]

Preprocessor macros

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

[edit] 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;

[edit] 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;
};

[edit] 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;
};

[edit] 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;
};

[edit] 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;