Standard library header  (C++11) (original) (raw)

This header is part of the concurrency support library.

[edit] Synopsis

namespace std { /* until C++20: enum memory_order { memory_order_relaxed, memory_order_consume, memory_order_acquire, memory_order_release, memory_order_acq_rel, memory_order_seq_cst }; /   enum class memory_order : / unspecified /; inline constexpr memory_order memory_order_relaxed = memory_order::relaxed; inline constexpr memory_order memory_order_consume = memory_order::consume; inline constexpr memory_order memory_order_acquire = memory_order::acquire; inline constexpr memory_order memory_order_release = memory_order::release; inline constexpr memory_order memory_order_acq_rel = memory_order::acq_rel; inline constexpr memory_order memory_order_seq_cst = memory_order::seq_cst;   template T kill_dependency(T y) noexcept;   // lock-free property #define ATOMIC_BOOL_LOCK_FREE / unspecified / #define ATOMIC_CHAR_LOCK_FREE / unspecified / #define ATOMIC_CHAR8_T_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 /   // class template atomic_ref template struct atomic_ref; // partial specialization for pointers template struct atomic_ref<T*>;   // class template atomic template struct atomic; // partial specialization for pointers template struct atomic<T*>;   // non-member functions template bool atomic_is_lock_free(const volatile atomic) noexcept; template bool atomic_is_lock_free(const atomic) noexcept; template void atomic_store(volatile atomic, typename atomic::value_type) noexcept; template void atomic_store(atomic, typename atomic::value_type) noexcept; template void atomic_store_explicit(volatile atomic, typename atomic::value_type, memory_order) noexcept; template void atomic_store_explicit(atomic, typename atomic::value_type, memory_order) noexcept; template T atomic_load(const volatile atomic) noexcept; template T atomic_load(const atomic) noexcept; template T atomic_load_explicit(const volatile atomic, memory_order) noexcept; template T atomic_load_explicit(const atomic, memory_order) noexcept; template T atomic_exchange(volatile atomic, typename atomic::value_type) noexcept; template T atomic_exchange(atomic, typename atomic::value_type) noexcept; template T atomic_exchange_explicit(volatile atomic, typename atomic::value_type, memory_order) noexcept; template T atomic_exchange_explicit(atomic, typename atomic::value_type, memory_order) noexcept; template bool atomic_compare_exchange_weak(volatile atomic, typename atomic::value_type*, typename atomic::value_type) noexcept; template bool atomic_compare_exchange_weak(atomic, typename atomic::value_type, typename atomic::value_type) noexcept; template bool atomic_compare_exchange_strong(volatile atomic, typename atomic::value_type, typename atomic::value_type) noexcept; template bool atomic_compare_exchange_strong(atomic, typename atomic::value_type, typename atomic::value_type) noexcept; template bool atomic_compare_exchange_weak_explicit(volatile atomic, typename atomic::value_type, typename atomic::value_type, memory_order, memory_order) noexcept; template bool atomic_compare_exchange_weak_explicit(atomic, typename atomic::value_type, typename atomic::value_type, memory_order, memory_order) noexcept; template bool atomic_compare_exchange_strong_explicit(volatile atomic, typename atomic::value_type, typename atomic::value_type, memory_order, memory_order) noexcept; template bool atomic_compare_exchange_strong_explicit(atomic, typename atomic::value_type, typename atomic::value_type, memory_order, memory_order) noexcept;   template T atomic_fetch_add(volatile atomic, typename atomic::difference_type) noexcept; template T atomic_fetch_add(atomic, typename atomic::difference_type) noexcept; template T atomic_fetch_add_explicit(volatile atomic, typename atomic::difference_type, memory_order) noexcept; template T atomic_fetch_add_explicit(atomic, typename atomic::difference_type, memory_order) noexcept; template T atomic_fetch_sub(volatile atomic, typename atomic::difference_type) noexcept; template T atomic_fetch_sub(atomic, typename atomic::difference_type) noexcept; template T atomic_fetch_sub_explicit(volatile atomic, typename atomic::difference_type, memory_order) noexcept; template T atomic_fetch_sub_explicit(atomic, typename atomic::difference_type, memory_order) noexcept; template T atomic_fetch_and(volatile atomic, typename atomic::value_type) noexcept; template T atomic_fetch_and(atomic, typename atomic::value_type) noexcept; template T atomic_fetch_and_explicit(volatile atomic, typename atomic::value_type, memory_order) noexcept; template T atomic_fetch_and_explicit(atomic, typename atomic::value_type, memory_order) noexcept; template T atomic_fetch_or(volatile atomic, typename atomic::value_type) noexcept; template T atomic_fetch_or(atomic, typename atomic::value_type) noexcept; template T atomic_fetch_or_explicit(volatile atomic, typename atomic::value_type, memory_order) noexcept; template T atomic_fetch_or_explicit(atomic, typename atomic::value_type, memory_order) noexcept; template T atomic_fetch_xor(volatile atomic, typename atomic::value_type) noexcept; template T atomic_fetch_xor(atomic, typename atomic::value_type) noexcept; template T atomic_fetch_xor_explicit(volatile atomic, typename atomic::value_type, memory_order) noexcept; template T atomic_fetch_xor_explicit(atomic, typename atomic::value_type, memory_order) noexcept; template T atomic_fetch_max(volatile atomic, typename atomic::value_type) noexcept; template T atomic_fetch_max(atomic, typename atomic::value_type) noexcept; template T atomic_fetch_max_explicit(volatile atomic, typename atomic::value_type, memory_order) noexcept; template T atomic_fetch_max_explicit(atomic, typename atomic::value_type, memory_order) noexcept; template T atomic_fetch_min(volatile atomic, typename atomic::value_type) noexcept; template T atomic_fetch_min(atomic, typename atomic::value_type) noexcept; template T atomic_fetch_min_explicit(volatile atomic, typename atomic::value_type, memory_order) noexcept; template T atomic_fetch_min_explicit(atomic, typename atomic::value_type, memory_order) noexcept;   template void atomic_wait(const volatile atomic, typename atomic::value_type); template void atomic_wait(const atomic, typename atomic::value_type); template void atomic_wait_explicit(const volatile atomic, typename atomic::value_type, memory_order); template void atomic_wait_explicit(const atomic, typename atomic::value_type, memory_order); template void atomic_notify_one(volatile atomic); template void atomic_notify_one(atomic); template void atomic_notify_all(volatile atomic); template void atomic_notify_all(atomic);   // type aliases using atomic_bool = atomic; using atomic_char = atomic; using atomic_schar = atomic; using atomic_uchar = atomic; using atomic_short = atomic; using atomic_ushort = atomic; using atomic_int = atomic; using atomic_uint = atomic; using atomic_long = atomic; using atomic_ulong = atomic; using atomic_llong = atomic; using atomic_ullong = atomic; using atomic_char8_t = atomic; using atomic_char16_t = atomic; using atomic_char32_t = atomic; using atomic_wchar_t = atomic;   using atomic_int8_t = atomic; using atomic_uint8_t = atomic; using atomic_int16_t = atomic; using atomic_uint16_t = atomic; using atomic_int32_t = atomic; using atomic_uint32_t = atomic; using atomic_int64_t = atomic; using atomic_uint64_t = atomic;   using atomic_int_least8_t = atomic; using atomic_uint_least8_t = atomic; using atomic_int_least16_t = atomic; using atomic_uint_least16_t = atomic; using atomic_int_least32_t = atomic; using atomic_uint_least32_t = atomic; using atomic_int_least64_t = atomic; using atomic_uint_least64_t = atomic;   using atomic_int_fast8_t = atomic; using atomic_uint_fast8_t = atomic; using atomic_int_fast16_t = atomic; using atomic_uint_fast16_t = atomic; using atomic_int_fast32_t = atomic; using atomic_uint_fast32_t = atomic; using atomic_int_fast64_t = atomic; using atomic_uint_fast64_t = atomic;   using atomic_intptr_t = atomic; using atomic_uintptr_t = atomic; using atomic_size_t = atomic; using atomic_ptrdiff_t = atomic; using atomic_intmax_t = atomic; using atomic_uintmax_t = atomic;   using atomic_signed_lock_free = /* see description /; using atomic_unsigned_lock_free = / see description /;   // flag type and operations struct atomic_flag;   bool atomic_flag_test(const volatile atomic_flag) noexcept; bool atomic_flag_test(const atomic_flag*) noexcept; bool atomic_flag_test_explicit(const volatile atomic_flag*, memory_order) noexcept; bool atomic_flag_test_explicit(const atomic_flag*, memory_order) noexcept; 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;   void atomic_flag_wait(const volatile atomic_flag*, bool) noexcept; void atomic_flag_wait(const atomic_flag*, bool) noexcept; void atomic_flag_wait_explicit(const volatile atomic_flag*, bool, memory_order) noexcept; void atomic_flag_wait_explicit(const atomic_flag*, bool, memory_order) noexcept; void atomic_flag_notify_one(volatile atomic_flag*) noexcept; void atomic_flag_notify_one(atomic_flag*) noexcept; void atomic_flag_notify_all(volatile atomic_flag*) noexcept; void atomic_flag_notify_all(atomic_flag*) noexcept;   // fences extern "C" void atomic_thread_fence(memory_order) noexcept; extern "C" void atomic_signal_fence(memory_order) noexcept; }   // deprecated namespace std { template void atomic_init(volatile atomic, typename atomic::value_type) noexcept; template void atomic_init(atomic, typename atomic::value_type) noexcept;   #define ATOMIC_VAR_INIT(value) /* see description /   #define ATOMIC_FLAG_INIT / see description */ }

[edit] Class template std::atomic

namespace std { template struct atomic { using value_type = T;   static constexpr bool is_always_lock_free = /* implementation-defined */; bool is_lock_free() const volatile noexcept; bool is_lock_free() const noexcept;   // operations on atomic types constexpr atomic() noexcept(is_nothrow_default_constructible_v); constexpr atomic(T) noexcept; atomic(const atomic&) = delete; atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete;   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; void store(T, memory_order = memory_order::seq_cst) volatile noexcept; void store(T, memory_order = memory_order::seq_cst) noexcept; T operator=(T) volatile noexcept; T operator=(T) 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;   void wait(T, memory_order = memory_order::seq_cst) const volatile noexcept; void wait(T, memory_order = memory_order::seq_cst) const noexcept; void notify_one() volatile noexcept; void notify_one() noexcept; void notify_all() volatile noexcept; void notify_all() noexcept; }; }

[edit] Specializations of std::atomic for integral types

namespace std { template<> struct atomic</* integral /> { using value_type = / integral /; using difference_type = value_type;   static constexpr bool is_always_lock_free = / implementation-defined /; bool is_lock_free() const volatile noexcept; bool is_lock_free() const noexcept;   constexpr atomic() noexcept; constexpr atomic(/ integral /) noexcept; atomic(const atomic&) = delete; atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete;   void store(/ integral /, memory_order = memory_order::seq_cst) volatile noexcept; void store(/ integral /, memory_order = memory_order::seq_cst) noexcept; / integral / operator=(/ integral /) volatile noexcept; / integral / operator=(/ integral /) 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; / integral / fetch_max(/ integral /, memory_order = memory_order::seq_cst) volatile noexcept; / integral / fetch_max(/ integral /, memory_order = memory_order::seq_cst) noexcept; / integral / fetch_min(/ integral /, memory_order = memory_order::seq_cst) volatile noexcept; / integral / fetch_min(/ integral /, memory_order = memory_order::seq_cst) 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;   void wait(/ integral /, memory_order = memory_order::seq_cst) const volatile noexcept; void wait(/ integral */, memory_order = memory_order::seq_cst) const noexcept; void notify_one() volatile noexcept; void notify_one() noexcept; void notify_all() volatile noexcept; void notify_all() noexcept; }; }

[edit] Specializations of std::atomic for floating-point types

namespace std { template<> struct atomic</* floating-point /> { using value_type = / floating-point /; using difference_type = value_type;   static constexpr bool is_always_lock_free = / implementation-defined /; bool is_lock_free() const volatile noexcept; bool is_lock_free() const noexcept;   constexpr atomic() noexcept; constexpr atomic(/ floating-point /) noexcept; atomic(const atomic&) = delete; atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete;   void store(/ floating-point /, memory_order = memory_order_seq_cst) volatile noexcept; void store(/ floating-point /, memory_order = memory_order_seq_cst) noexcept; / floating-point / operator=(/ floating-point /) volatile noexcept; / floating-point / operator=(/ floating-point /) noexcept; / floating-point / load(memory_order = memory_order_seq_cst) volatile noexcept; / floating-point / load(memory_order = memory_order_seq_cst) noexcept; operator / floating-point /() volatile noexcept; operator / floating-point /() noexcept;   / floating-point / exchange(/ floating-point /, memory_order = memory_order_seq_cst) volatile noexcept; / floating-point / exchange(/ floating-point /, memory_order = memory_order_seq_cst) noexcept; bool compare_exchange_weak(/ floating-point /&, / floating-point /, memory_order, memory_order) volatile noexcept; bool compare_exchange_weak(/ floating-point /&, / floating-point /, memory_order, memory_order) noexcept; bool compare_exchange_strong(/ floating-point /&, / floating-point /, memory_order, memory_order) volatile noexcept; bool compare_exchange_strong(/ floating-point /&, / floating-point /, memory_order, memory_order) noexcept; bool compare_exchange_weak(/ floating-point /&, / floating-point /, memory_order = memory_order_seq_cst) volatile noexcept; bool compare_exchange_weak(/ floating-point /&, / floating-point /, memory_order = memory_order_seq_cst) noexcept; bool compare_exchange_strong(/ floating-point /&, / floating-point /, memory_order = memory_order_seq_cst) volatile noexcept; bool compare_exchange_strong(/ floating-point /&, / floating-point /, memory_order = memory_order_seq_cst) noexcept;   / floating-point / fetch_add(/ floating-point /, memory_order = memory_order_seq_cst) volatile noexcept; / floating-point / fetch_add(/ floating-point /, memory_order = memory_order_seq_cst) noexcept; / floating-point / fetch_sub(/ floating-point /, memory_order = memory_order_seq_cst) volatile noexcept; / floating-point / fetch_sub(/ floating-point /, memory_order = memory_order_seq_cst) noexcept;   / floating-point / operator+=(/ floating-point /) volatile noexcept; / floating-point / operator+=(/ floating-point /) noexcept; / floating-point / operator-=(/ floating-point /) volatile noexcept; / floating-point / operator-=(/ floating-point /) noexcept;   void wait(/ floating-point /, memory_order = memory_order::seq_cst) const volatile noexcept; void wait(/ floating-point */, memory_order = memory_order::seq_cst) const noexcept; void notify_one() volatile noexcept; void notify_one() noexcept; void notify_all() volatile noexcept; void notify_all() noexcept; }; }

[edit] Specializations of std::atomic for pointer types

namespace std { template struct atomic<T*> { using value_type = T*; using difference_type = ptrdiff_t;   static constexpr bool is_always_lock_free = /* implementation-defined /; bool is_lock_free() const volatile noexcept; bool is_lock_free() const noexcept;   constexpr atomic() noexcept; constexpr atomic(T) noexcept; atomic(const atomic&) = delete; atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete;   void store(T*, memory_order = memory_order::seq_cst) volatile noexcept; void store(T*, memory_order = memory_order::seq_cst) noexcept; T* operator=(T*) volatile noexcept; T* operator=(T*) 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; T* fetch_max(T*, memory_order = memory_order::seq_cst) volatile noexcept; T* fetch_max(T*, memory_order = memory_order::seq_cst) noexcept; T* fetch_min(T*, memory_order = memory_order::seq_cst) volatile noexcept; T* fetch_min(T*, memory_order = memory_order::seq_cst) 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;   void wait(T*, memory_order = memory_order::seq_cst) const volatile noexcept; void wait(T*, memory_order = memory_order::seq_cst) const noexcept; void notify_one() volatile noexcept; void notify_one() noexcept; void notify_all() volatile noexcept; void notify_all() noexcept; }; }

[edit] Class template std::atomic_ref

namespace std { template struct atomic_ref { private: T* ptr; // exposition only public: using value_type = T; static constexpr size_t required_alignment = /* implementation-defined /;   static constexpr bool is_always_lock_free = / implementation-defined */; bool is_lock_free() const noexcept;   explicit atomic_ref(T&); atomic_ref(const atomic_ref&) noexcept; atomic_ref& operator=(const atomic_ref&) = delete;   void store(T, memory_order = memory_order_seq_cst) const noexcept; T operator=(T) const noexcept; T load(memory_order = memory_order_seq_cst) const noexcept; operator T() const noexcept;   T exchange(T, memory_order = memory_order_seq_cst) const noexcept; bool compare_exchange_weak(T&, T, memory_order, memory_order) const noexcept; bool compare_exchange_strong(T&, T, memory_order, memory_order) const noexcept; bool compare_exchange_weak(T&, T, memory_order = memory_order_seq_cst) const noexcept; bool compare_exchange_strong(T&, T, memory_order = memory_order_seq_cst) const noexcept;   void wait(T, memory_order = memory_order::seq_cst) const noexcept; void notify_one() const noexcept; void notify_all() const noexcept; }; }

[edit] Specializations of std::atomic_ref for integral types

namespace std { template<> struct atomic_ref</* integral /> { private: / integral / ptr; // exposition only public: using value_type = /* integral /; using difference_type = value_type; static constexpr size_t required_alignment = / implementation-defined /;   static constexpr bool is_always_lock_free = / implementation-defined /; bool is_lock_free() const noexcept;   explicit atomic_ref(/ integral /&); atomic_ref(const atomic_ref&) noexcept; atomic_ref& operator=(const atomic_ref&) = delete;   void store(/ integral /, memory_order = memory_order_seq_cst) const noexcept; / integral / operator=(/ integral /) const noexcept; / integral / load(memory_order = memory_order_seq_cst) const noexcept; operator / integral /() const noexcept;   / integral / exchange(/ integral /, memory_order = memory_order_seq_cst) const noexcept; bool compare_exchange_weak(/ integral /&, / integral /, memory_order, memory_order) const noexcept; bool compare_exchange_strong(/ integral /&, / integral /, memory_order, memory_order) const noexcept; bool compare_exchange_weak(/ integral /&, / integral /, memory_order = memory_order_seq_cst) const noexcept; bool compare_exchange_strong(/ integral /&, / integral /, memory_order = memory_order_seq_cst) const noexcept;   / integral / fetch_add(/ integral /, memory_order = memory_order_seq_cst) const noexcept; / integral / fetch_sub(/ integral /, memory_order = memory_order_seq_cst) const noexcept; / integral / fetch_and(/ integral /, memory_order = memory_order_seq_cst) const noexcept; / integral / fetch_or(/ integral /, memory_order = memory_order_seq_cst) const noexcept; / integral / fetch_xor(/ integral /, memory_order = memory_order_seq_cst) const noexcept; / integral / fetch_max(/ integral /, memory_order = memory_order_seq_cst) const noexcept; / integral / fetch_min(/ integral /, memory_order = memory_order_seq_cst) const noexcept;   / integral / operator++(int) const noexcept; / integral / operator--(int) const noexcept; / integral / operator++() const noexcept; / integral / operator--() const noexcept; / integral / operator+=(/ integral /) const noexcept; / integral / operator-=(/ integral /) const noexcept; / integral / operator&=(/ integral /) const noexcept; / integral */ operator

[edit] Specializations of std::atomic_ref for floating-point types

namespace std { template<> struct atomic_ref</* floating-point /> { private: / floating-point / ptr; // exposition only public: using value_type = /* floating-point /; using difference_type = value_type; static constexpr size_t required_alignment = / implementation-defined /;   static constexpr bool is_always_lock_free = / implementation-defined /; bool is_lock_free() const noexcept;   explicit atomic_ref(/ floating-point /&); atomic_ref(const atomic_ref&) noexcept; atomic_ref& operator=(const atomic_ref&) = delete;   void store(/ floating-point /, memory_order = memory_order_seq_cst) const noexcept; / floating-point / operator=(/ floating-point /) const noexcept; / floating-point / load(memory_order = memory_order_seq_cst) const noexcept; operator / floating-point /() const noexcept;   / floating-point / exchange(/ floating-point /, memory_order = memory_order_seq_cst) const noexcept; bool compare_exchange_weak(/ floating-point /&, / floating-point /, memory_order, memory_order) const noexcept; bool compare_exchange_strong(/ floating-point /&, / floating-point /, memory_order, memory_order) const noexcept; bool compare_exchange_weak(/ floating-point /&, / floating-point /, memory_order = memory_order_seq_cst) const noexcept; bool compare_exchange_strong(/ floating-point /&, / floating-point /, memory_order = memory_order_seq_cst) const noexcept;   / floating-point / fetch_add(/ floating-point /, memory_order = memory_order_seq_cst) const noexcept; / floating-point / fetch_sub(/ floating-point /, memory_order = memory_order_seq_cst) const noexcept;   / floating-point / operator+=(/ floating-point /) const noexcept; / floating-point / operator-=(/ floating-point /) const noexcept;   void wait(/ floating-point */, memory_order = memory_order::seq_cst) const noexcept; void notify_one() const noexcept; void notify_all() const noexcept; }; }

[edit] Specializations of std::atomic_ref for pointer types

namespace std { template struct atomic_ref<T*> { private: T** ptr; // exposition only public: using value_type = T*; using difference_type = ptrdiff_t; static constexpr size_t required_alignment = /* implementation-defined /;   static constexpr bool is_always_lock_free = / implementation-defined /; bool is_lock_free() const noexcept;   explicit atomic_ref(T&); atomic_ref(const atomic_ref&) noexcept; atomic_ref& operator=(const atomic_ref&) = delete;   void store(T*, memory_order = memory_order_seq_cst) const noexcept; T* operator=(T*) const noexcept; T* load(memory_order = memory_order_seq_cst) const noexcept; operator T*() const noexcept;   T* exchange(T*, memory_order = memory_order_seq_cst) const noexcept; bool compare_exchange_weak(T*&, T*, memory_order, memory_order) const noexcept; bool compare_exchange_strong(T*&, T*, memory_order, memory_order) const noexcept; bool compare_exchange_weak(T*&, T*, memory_order = memory_order_seq_cst) const noexcept; bool compare_exchange_strong(T*&, T*, memory_order = memory_order_seq_cst) const noexcept;   T* fetch_add(difference_type, memory_order = memory_order_seq_cst) const noexcept; T* fetch_sub(difference_type, memory_order = memory_order_seq_cst) const noexcept; T* fetch_max(T , memory_order = memory_order::seq_cst) const noexcept; T fetch_min(T , memory_order = memory_order::seq_cst) const noexcept;   T operator++(int) const noexcept; T* operator--(int) const noexcept; T* operator++() const noexcept; T* operator--() const noexcept; T* operator+=(difference_type) const noexcept; T* operator-=(difference_type) const noexcept;   void wait(T*, memory_order = memory_order::seq_cst) const noexcept; void notify_one() const noexcept; void notify_all() const noexcept; }; }

[edit] Class std::atomic_flag

namespace std { struct atomic_flag { constexpr atomic_flag() noexcept; atomic_flag(const atomic_flag&) = delete; atomic_flag& operator=(const atomic_flag&) = delete; atomic_flag& operator=(const atomic_flag&) volatile = delete;   bool test(memory_order = memory_order::seq_cst) const volatile noexcept; bool test(memory_order = memory_order::seq_cst) const noexcept; 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;   void wait(bool, memory_order = memory_order::seq_cst) const volatile noexcept; void wait(bool, memory_order = memory_order::seq_cst) const noexcept; void notify_one() volatile noexcept; void notify_one() noexcept; void notify_all() volatile noexcept; void notify_all() noexcept; }; }