# Standard library header <atomic>

From cppreference.com
< cpp‎ | header

This header is part of the atomic operations library.

### Classes

atomic (C++11) | atomic class template and specializations for bool, integral, and pointer types (class template)
atomic_flag (C++11) | the lock-free boolean atomic type (class)
memory_order (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

atomic_is_lock_free (C++11) | checks if the atomic type's operations are lock-free (function template)
atomic_store atomic_store_explicit (C++11)(C++11) | atomically replaces the value of the atomic object with a non-atomic argument (function template)
atomic_load atomic_load_explicit (C++11)(C++11) | atomically obtains the value stored in an atomic object (function template)
atomic_exchange atomic_exchange_explicit (C++11)(C++11) | atomically replaces the value of the atomic object with non-atomic argument and returns the old value of the atomic (function template)
atomic_compare_exchange_weak atomic_compare_exchange_weak_explicit atomic_compare_exchange_strong atomic_compare_exchange_strong_explicit (C++11)(C++11)(C++11)(C++11) | 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)
atomic_fetch_add atomic_fetch_add_explicit (C++11)(C++11) | adds a non-atomic value to an atomic object and obtains the previous value of the atomic (function template)
atomic_fetch_sub atomic_fetch_sub_explicit (C++11)(C++11) | subtracts a non-atomic value from an atomic object and obtains the previous value of the atomic (function template)
atomic_fetch_and atomic_fetch_and_explicit (C++11)(C++11) | 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)
atomic_fetch_or atomic_fetch_or_explicit (C++11)(C++11) | 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)
atomic_fetch_xor atomic_fetch_xor_explicit (C++11)(C++11) | 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)
atomic_flag_test_and_set atomic_flag_test_and_set_explicit (C++11)(C++11) | atomically sets the flag to true and returns its previous value (function)
atomic_flag_clear atomic_flag_clear_explicit (C++11)(C++11) | atomically sets the value of the flag to false (function)
atomic_init (C++11) | non-atomic initialization of a default-constructed atomic object (function template)
kill_dependency (C++11) | removes the specified object from the std::memory_order_consume dependency tree (function template)
atomic_thread_fence (C++11) | generic memory order-dependent fence synchronization primitive (function)
atomic_signal_fence (C++11) | fence between a thread and a signal handler executed in the same thread (function)

### Preprocessor macros

ATOMIC_VAR_INIT (C++11) | constant initialization of an atomic variable of static storage duration (function macro)
ATOMIC_FLAG_INIT (C++11) | 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;

Retrieved from "http://en.cppreference.com/mwiki/index.php?title=cpp/header/atomic&oldid=87462"