Standard library header <atomic> (C++11)
From cppreference.com
This header is part of the concurrency support library.
Classes | |
(C++11) | atomic class template and specializations for bool, integral, floating-point,(since C++20) and pointer types (class template) |
(C++20) | provides atomic operations on non-atomic objects (class template) |
(C++11) | the lock-free boolean atomic type (class) |
(C++11) | defines memory ordering constraints for the given atomic operation (enum) |
(C++11) | std::atomic<bool> (typedef) |
(C++11) | std::atomic<char> (typedef) |
(C++11) | std::atomic<signedchar> (typedef) |
(C++11) | std::atomic<unsignedchar> (typedef) |
(C++11) | std::atomic<short> (typedef) |
(C++11) | std::atomic<unsignedshort> (typedef) |
(C++11) | std::atomic<int> (typedef) |
(C++11) | std::atomic<unsignedint> (typedef) |
(C++11) | std::atomic<long> (typedef) |
(C++11) | std::atomic<unsignedlong> (typedef) |
(C++11) | std::atomic<longlong> (typedef) |
(C++11) | std::atomic<unsignedlonglong> (typedef) |
(C++20) | std::atomic<char8_t> (typedef) |
(C++11) | std::atomic<char16_t> (typedef) |
(C++11) | std::atomic<char32_t> (typedef) |
(C++11) | std::atomic<wchar_t> (typedef) |
(C++11)(optional) | std::atomic<std::int8_t> (typedef) |
(C++11)(optional) | std::atomic<std::uint8_t> (typedef) |
(C++11)(optional) | std::atomic<std::int16_t> (typedef) |
(C++11)(optional) | std::atomic<std::uint16_t> (typedef) |
(C++11)(optional) | std::atomic<std::int32_t> (typedef) |
(C++11)(optional) | std::atomic<std::uint32_t> (typedef) |
(C++11)(optional) | std::atomic<std::int64_t> (typedef) |
(C++11)(optional) | std::atomic<std::uint64_t> (typedef) |
(C++11) | std::atomic<std::int_least8_t> (typedef) |
(C++11) | std::atomic<std::uint_least8_t> (typedef) |
(C++11) | std::atomic<std::int_least16_t> (typedef) |
(C++11) | std::atomic<std::uint_least16_t> (typedef) |
(C++11) | std::atomic<std::int_least32_t> (typedef) |
(C++11) | std::atomic<std::uint_least32_t> (typedef) |
(C++11) | std::atomic<std::int_least64_t> (typedef) |
(C++11) | std::atomic<std::uint_least64_t> (typedef) |
(C++11) | std::atomic<std::int_fast8_t> (typedef) |
(C++11) | std::atomic<std::uint_fast8_t> (typedef) |
(C++11) | std::atomic<std::int_fast16_t> (typedef) |
(C++11) | std::atomic<std::uint_fast16_t> (typedef) |
(C++11) | std::atomic<std::int_fast32_t> (typedef) |
(C++11) | std::atomic<std::uint_fast32_t> (typedef) |
(C++11) | std::atomic<std::int_fast64_t> (typedef) |
(C++11) | std::atomic<std::uint_fast64_t> (typedef) |
(C++11)(optional) | std::atomic<std::intptr_t> (typedef) |
(C++11)(optional) | std::atomic<std::uintptr_t> (typedef) |
(C++11) | std::atomic<std::size_t> (typedef) |
(C++11) | std::atomic<std::ptrdiff_t> (typedef) |
(C++11) | std::atomic<std::intmax_t> (typedef) |
(C++11) | std::atomic<std::uintmax_t> (typedef) |
(C++20) | a signed integral atomic type that is lock-free and for which waiting/notifying is most efficient (typedef) |
(C++20) | an unsigned integral atomic type that is lock-free and for which waiting/notifying is most efficient (typedef) |
Functions | |
(C++11) | checks if the atomic type's operations are lock-free (function template) |
(C++11)(C++11) | atomically replaces the value of the atomic object with a non-atomic argument (function template) |
(C++11)(C++11) | atomically obtains the value stored in an atomic object (function template) |
(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) |
| 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) | |
(C++11)(C++11) | adds a non-atomic value to an atomic object and obtains the previous value of the atomic (function template) |
(C++11)(C++11) | subtracts a non-atomic value from an atomic object and obtains the previous value of the atomic (function template) |
(C++11)(C++11) | replaces the atomic object with the result of bitwise AND with a non-atomic argument and obtains the previous value of the atomic (function template) |
(C++11)(C++11) | replaces the atomic object with the result of bitwise OR with a non-atomic argument and obtains the previous value of the atomic (function template) |
(C++11)(C++11) | replaces the atomic object with the result of bitwise XOR with a non-atomic argument and obtains the previous value of the atomic (function template) |
(C++26)(C++26) | replaces the atomic object with the result of std::max with a non-atomic argument and obtains the previous value of the atomic (function template) |
(C++26)(C++26) | replaces the atomic object with the result of std::min with a non-atomic argument and obtains the previous value of the atomic (function template) |
(C++20)(C++20) | blocks the thread until notified and the atomic value changes (function template) |
(C++20) | notifies a thread blocked in atomic_wait (function template) |
(C++20) | notifies all threads blocked in atomic_wait (function template) |
(C++20)(C++20) | atomically returns the value of the flag (function) |
| atomically sets the flag to true and returns its previous value (function) | |
(C++11)(C++11) | atomically sets the value of the flag to false (function) |
(C++20)(C++20) | blocks the thread until notified and the flag changes (function) |
(C++20) | notifies a thread blocked in atomic_flag_wait (function) |
(C++20) | notifies all threads blocked in atomic_flag_wait (function) |
(C++11)(deprecated in C++20) | non-atomic initialization of a default-constructed atomic object (function template) |
(C++11)(deprecated in C++26) | removes the specified object from the std::memory_order_consume dependency tree (function template) |
(C++11) | generic memory order-dependent fence synchronization primitive (function) |
(C++11) | fence between a thread and a signal handler executed in the same thread (function) |
Macros | |
(C++11)(deprecated in C++20) | constant initialization of an atomic variable of static storage duration (function macro) |
(C++11) | initializes an std::atomic_flag to false (macro constant) |
[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 }; */ enumclass memory_order :/* unspecified */;inlineconstexpr memory_order memory_order_relaxed = memory_order::relaxed;inlineconstexpr memory_order memory_order_consume = memory_order::consume;inlineconstexpr memory_order memory_order_acquire = memory_order::acquire;inlineconstexpr memory_order memory_order_release = memory_order::release;inlineconstexpr memory_order memory_order_acq_rel = memory_order::acq_rel;inlineconstexpr memory_order memory_order_seq_cst = memory_order::seq_cst; 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_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_reftemplate<class T>struct atomic_ref;// partial specialization for pointerstemplate<class T>struct atomic_ref<T*>; // class template atomictemplate<class T>struct atomic;// partial specialization for pointerstemplate<class T>struct atomic<T*>; // non-member functionstemplate<class T>bool atomic_is_lock_free(constvolatile atomic<T>*)noexcept;template<class T>bool atomic_is_lock_free(const atomic<T>*)noexcept;template<class T>void atomic_store(volatile atomic<T>*, typename atomic<T>::value_type)noexcept;template<class T>void atomic_store(atomic<T>*, typename atomic<T>::value_type)noexcept;template<class T>void atomic_store_explicit(volatile atomic<T>*, typename atomic<T>::value_type, memory_order)noexcept;template<class T>void atomic_store_explicit(atomic<T>*, typename atomic<T>::value_type, memory_order)noexcept;template<class T> T atomic_load(constvolatile atomic<T>*)noexcept;template<class T> T atomic_load(const atomic<T>*)noexcept;template<class T> T atomic_load_explicit(constvolatile atomic<T>*, memory_order)noexcept;template<class T> T atomic_load_explicit(const atomic<T>*, memory_order)noexcept;template<class T> T atomic_exchange(volatile atomic<T>*, typename atomic<T>::value_type)noexcept;template<class T> T atomic_exchange(atomic<T>*, typename atomic<T>::value_type)noexcept;template<class T> T atomic_exchange_explicit(volatile atomic<T>*, typename atomic<T>::value_type, memory_order)noexcept;template<class T> T atomic_exchange_explicit(atomic<T>*, typename atomic<T>::value_type, memory_order)noexcept;template<class T>bool atomic_compare_exchange_weak(volatile atomic<T>*, typename atomic<T>::value_type*, typename atomic<T>::value_type)noexcept;template<class T>bool atomic_compare_exchange_weak(atomic<T>*, typename atomic<T>::value_type*, typename atomic<T>::value_type)noexcept;template<class T>bool atomic_compare_exchange_strong(volatile atomic<T>*, typename atomic<T>::value_type*, typename atomic<T>::value_type)noexcept;template<class T>bool atomic_compare_exchange_strong(atomic<T>*, typename atomic<T>::value_type*, typename atomic<T>::value_type)noexcept;template<class T>bool atomic_compare_exchange_weak_explicit(volatile atomic<T>*, typename atomic<T>::value_type*, typename atomic<T>::value_type, memory_order, memory_order)noexcept;template<class T>bool atomic_compare_exchange_weak_explicit(atomic<T>*, typename atomic<T>::value_type*, typename atomic<T>::value_type, memory_order, memory_order)noexcept;template<class T>bool atomic_compare_exchange_strong_explicit(volatile atomic<T>*, typename atomic<T>::value_type*, typename atomic<T>::value_type, memory_order, memory_order)noexcept;template<class T>bool atomic_compare_exchange_strong_explicit(atomic<T>*, typename atomic<T>::value_type*, typename atomic<T>::value_type, memory_order, memory_order)noexcept; template<class T> T atomic_fetch_add(volatile atomic<T>*, typename atomic<T>::difference_type)noexcept;template<class T> T atomic_fetch_add(atomic<T>*, typename atomic<T>::difference_type)noexcept;template<class T> T atomic_fetch_add_explicit(volatile atomic<T>*, typename atomic<T>::difference_type, memory_order)noexcept;template<class T> T atomic_fetch_add_explicit(atomic<T>*, typename atomic<T>::difference_type, memory_order)noexcept;template<class T> T atomic_fetch_sub(volatile atomic<T>*, typename atomic<T>::difference_type)noexcept;template<class T> T atomic_fetch_sub(atomic<T>*, typename atomic<T>::difference_type)noexcept;template<class T> T atomic_fetch_sub_explicit(volatile atomic<T>*, typename atomic<T>::difference_type, memory_order)noexcept;template<class T> T atomic_fetch_sub_explicit(atomic<T>*, typename atomic<T>::difference_type, memory_order)noexcept;template<class T> T atomic_fetch_and(volatile atomic<T>*, typename atomic<T>::value_type)noexcept;template<class T> T atomic_fetch_and(atomic<T>*, typename atomic<T>::value_type)noexcept;template<class T> T atomic_fetch_and_explicit(volatile atomic<T>*, typename atomic<T>::value_type, memory_order)noexcept;template<class T> T atomic_fetch_and_explicit(atomic<T>*, typename atomic<T>::value_type, memory_order)noexcept;template<class T> T atomic_fetch_or(volatile atomic<T>*, typename atomic<T>::value_type)noexcept;template<class T> T atomic_fetch_or(atomic<T>*, typename atomic<T>::value_type)noexcept;template<class T> T atomic_fetch_or_explicit(volatile atomic<T>*, typename atomic<T>::value_type, memory_order)noexcept;template<class T> T atomic_fetch_or_explicit(atomic<T>*, typename atomic<T>::value_type, memory_order)noexcept;template<class T> T atomic_fetch_xor(volatile atomic<T>*, typename atomic<T>::value_type)noexcept;template<class T> T atomic_fetch_xor(atomic<T>*, typename atomic<T>::value_type)noexcept;template<class T> T atomic_fetch_xor_explicit(volatile atomic<T>*, typename atomic<T>::value_type, memory_order)noexcept;template<class T> T atomic_fetch_xor_explicit(atomic<T>*, typename atomic<T>::value_type, memory_order)noexcept;template<class T> T atomic_fetch_max(volatile atomic<T>*, typename atomic<T>::value_type)noexcept;template<class T> T atomic_fetch_max(atomic<T>*, typename atomic<T>::value_type)noexcept;template<class T> T atomic_fetch_max_explicit(volatile atomic<T>*, typename atomic<T>::value_type, memory_order)noexcept;template<class T> T atomic_fetch_max_explicit(atomic<T>*, typename atomic<T>::value_type, memory_order)noexcept;template<class T> T atomic_fetch_min(volatile atomic<T>*, typename atomic<T>::value_type)noexcept;template<class T> T atomic_fetch_min(atomic<T>*, typename atomic<T>::value_type)noexcept;template<class T> T atomic_fetch_min_explicit(volatile atomic<T>*, typename atomic<T>::value_type, memory_order)noexcept;template<class T> T atomic_fetch_min_explicit(atomic<T>*, typename atomic<T>::value_type, memory_order)noexcept; template<class T>void atomic_wait(constvolatile atomic<T>*, typename atomic<T>::value_type);template<class T>void atomic_wait(const atomic<T>*, typename atomic<T>::value_type);template<class T>void atomic_wait_explicit(constvolatile atomic<T>*, typename atomic<T>::value_type, memory_order);template<class T>void atomic_wait_explicit(const atomic<T>*, typename atomic<T>::value_type, memory_order);template<class T>void atomic_notify_one(volatile atomic<T>*);template<class T>void atomic_notify_one(atomic<T>*);template<class T>void atomic_notify_all(volatile atomic<T>*);template<class T>void atomic_notify_all(atomic<T>*); // type aliasesusing atomic_bool = atomic<bool>;using atomic_char = atomic<char>;using atomic_schar = atomic<signedchar>;using atomic_uchar = atomic<unsignedchar>;using atomic_short = atomic<short>;using atomic_ushort = atomic<unsignedshort>;using atomic_int = atomic<int>;using atomic_uint = atomic<unsignedint>;using atomic_long = atomic<long>;using atomic_ulong = atomic<unsignedlong>;using atomic_llong = atomic<longlong>;using atomic_ullong = atomic<unsignedlonglong>;using atomic_char8_t = atomic<char8_t>;using atomic_char16_t = atomic<char16_t>;using atomic_char32_t = atomic<char32_t>;using atomic_wchar_t = atomic<wchar_t>; using atomic_int8_t = atomic<int8_t>;using atomic_uint8_t = atomic<uint8_t>;using atomic_int16_t = atomic<int16_t>;using atomic_uint16_t = atomic<uint16_t>;using atomic_int32_t = atomic<int32_t>;using atomic_uint32_t = atomic<uint32_t>;using atomic_int64_t = atomic<int64_t>;using atomic_uint64_t = atomic<uint64_t>; using atomic_int_least8_t = atomic<int_least8_t>;using atomic_uint_least8_t = atomic<uint_least8_t>;using atomic_int_least16_t = atomic<int_least16_t>;using atomic_uint_least16_t = atomic<uint_least16_t>;using atomic_int_least32_t = atomic<int_least32_t>;using atomic_uint_least32_t = atomic<uint_least32_t>;using atomic_int_least64_t = atomic<int_least64_t>;using atomic_uint_least64_t = atomic<uint_least64_t>; using atomic_int_fast8_t = atomic<int_fast8_t>;using atomic_uint_fast8_t = atomic<uint_fast8_t>;using atomic_int_fast16_t = atomic<int_fast16_t>;using atomic_uint_fast16_t = atomic<uint_fast16_t>;using atomic_int_fast32_t = atomic<int_fast32_t>;using atomic_uint_fast32_t = atomic<uint_fast32_t>;using atomic_int_fast64_t = atomic<int_fast64_t>;using atomic_uint_fast64_t = atomic<uint_fast64_t>; using atomic_intptr_t = atomic<intptr_t>;using atomic_uintptr_t = atomic<uintptr_t>;using atomic_size_t = atomic<size_t>;using atomic_ptrdiff_t = atomic<ptrdiff_t>;using atomic_intmax_t = atomic<intmax_t>;using atomic_uintmax_t = atomic<uintmax_t>; using atomic_signed_lock_free =/* see description */;using atomic_unsigned_lock_free =/* see description */; // flag type and operationsstruct atomic_flag; bool atomic_flag_test(constvolatile atomic_flag*)noexcept;bool atomic_flag_test(const atomic_flag*)noexcept;bool atomic_flag_test_explicit(constvolatile 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(constvolatile atomic_flag*, bool)noexcept;void atomic_flag_wait(const atomic_flag*, bool)noexcept;void atomic_flag_wait_explicit(constvolatile 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; // fencesextern"C"void atomic_thread_fence(memory_order)noexcept;extern"C"void atomic_signal_fence(memory_order)noexcept;} // deprecatednamespace std {template<class T>void atomic_init(volatile atomic<T>*, typename atomic<T>::value_type)noexcept;template<class T>void atomic_init(atomic<T>*, typename atomic<T>::value_type)noexcept; #define ATOMIC_VAR_INIT(value) /* see description */ #define ATOMIC_FLAG_INIT /* see description */}
[edit]Class template std::atomic
namespace std {template<class T>struct atomic {using value_type = T; staticconstexprbool is_always_lock_free =/* implementation-defined */;bool is_lock_free()constvolatilenoexcept;bool is_lock_free()constnoexcept; // operations on atomic typesconstexpr atomic()noexcept(is_nothrow_default_constructible_v<T>);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)constvolatilenoexcept; T load(memory_order = memory_order::seq_cst)constnoexcept; operator T()constvolatilenoexcept; operator T()constnoexcept;void store(T, memory_order = memory_order::seq_cst)volatilenoexcept;void store(T, memory_order = memory_order::seq_cst)noexcept; T operator=(T)volatilenoexcept; T operator=(T)noexcept; T exchange(T, memory_order = memory_order::seq_cst)volatilenoexcept; T exchange(T, memory_order = memory_order::seq_cst)noexcept;bool compare_exchange_weak(T&, T, memory_order, memory_order)volatilenoexcept;bool compare_exchange_weak(T&, T, memory_order, memory_order)noexcept;bool compare_exchange_strong(T&, T, memory_order, memory_order)volatilenoexcept;bool compare_exchange_strong(T&, T, memory_order, memory_order)noexcept;bool compare_exchange_weak(T&, T, memory_order = memory_order::seq_cst)volatilenoexcept;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)volatilenoexcept;bool compare_exchange_strong(T&, T, memory_order = memory_order::seq_cst)noexcept; void wait(T, memory_order = memory_order::seq_cst)constvolatilenoexcept;void wait(T, memory_order = memory_order::seq_cst)constnoexcept;void notify_one()volatilenoexcept;void notify_one()noexcept;void notify_all()volatilenoexcept;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; staticconstexprbool is_always_lock_free =/* implementation-defined */;bool is_lock_free()constvolatilenoexcept;bool is_lock_free()constnoexcept; 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)volatilenoexcept;void store(/* integral */, memory_order = memory_order::seq_cst)noexcept;/* integral */ operator=(/* integral */)volatilenoexcept;/* integral */ operator=(/* integral */)noexcept;/* integral */ load(memory_order = memory_order::seq_cst)constvolatilenoexcept;/* integral */ load(memory_order = memory_order::seq_cst)constnoexcept; operator /* integral */()constvolatilenoexcept; operator /* integral */()constnoexcept; /* integral */ exchange(/* integral */, memory_order = memory_order::seq_cst)volatilenoexcept;/* integral */ exchange(/* integral */, memory_order = memory_order::seq_cst)noexcept;bool compare_exchange_weak(/* integral */&, /* integral */, memory_order, memory_order)volatilenoexcept;bool compare_exchange_weak(/* integral */&, /* integral */, memory_order, memory_order)noexcept;bool compare_exchange_strong(/* integral */&, /* integral */, memory_order, memory_order)volatilenoexcept;bool compare_exchange_strong(/* integral */&, /* integral */, memory_order, memory_order)noexcept;bool compare_exchange_weak(/* integral */&, /* integral */, memory_order = memory_order::seq_cst)volatilenoexcept;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)volatilenoexcept;bool compare_exchange_strong(/* integral */&, /* integral */, memory_order = memory_order::seq_cst)noexcept; /* integral */ fetch_add(/* integral */, memory_order = memory_order::seq_cst)volatilenoexcept;/* integral */ fetch_add(/* integral */, memory_order = memory_order::seq_cst)noexcept;/* integral */ fetch_sub(/* integral */, memory_order = memory_order::seq_cst)volatilenoexcept;/* integral */ fetch_sub(/* integral */, memory_order = memory_order::seq_cst)noexcept;/* integral */ fetch_and(/* integral */, memory_order = memory_order::seq_cst)volatilenoexcept;/* integral */ fetch_and(/* integral */, memory_order = memory_order::seq_cst)noexcept;/* integral */ fetch_or(/* integral */, memory_order = memory_order::seq_cst)volatilenoexcept;/* integral */ fetch_or(/* integral */, memory_order = memory_order::seq_cst)noexcept;/* integral */ fetch_xor(/* integral */, memory_order = memory_order::seq_cst)volatilenoexcept;/* integral */ fetch_xor(/* integral */, memory_order = memory_order::seq_cst)noexcept;/* integral */ fetch_max(/* integral */, memory_order = memory_order::seq_cst)volatilenoexcept;/* integral */ fetch_max(/* integral */, memory_order = memory_order::seq_cst)noexcept;/* integral */ fetch_min(/* integral */, memory_order = memory_order::seq_cst)volatilenoexcept;/* integral */ fetch_min(/* integral */, memory_order = memory_order::seq_cst)noexcept; /* integral */ operator++(int)volatilenoexcept;/* integral */ operator++(int)noexcept;/* integral */ operator--(int)volatilenoexcept;/* integral */ operator--(int)noexcept;/* integral */ operator++()volatilenoexcept;/* integral */ operator++()noexcept;/* integral */ operator--()volatilenoexcept;/* integral */ operator--()noexcept;/* integral */ operator+=(/* integral */)volatilenoexcept;/* integral */ operator+=(/* integral */)noexcept;/* integral */ operator-=(/* integral */)volatilenoexcept;/* integral */ operator-=(/* integral */)noexcept;/* integral */ operator&=(/* integral */)volatilenoexcept;/* integral */ operator&=(/* integral */)noexcept;/* integral */ operator|=(/* integral */)volatilenoexcept;/* integral */ operator|=(/* integral */)noexcept;/* integral */ operator^=(/* integral */)volatilenoexcept;/* integral */ operator^=(/* integral */)noexcept; void wait(/* integral */, memory_order = memory_order::seq_cst)constvolatilenoexcept;void wait(/* integral */, memory_order = memory_order::seq_cst)constnoexcept;void notify_one()volatilenoexcept;void notify_one()noexcept;void notify_all()volatilenoexcept;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; staticconstexprbool is_always_lock_free =/* implementation-defined */;bool is_lock_free()constvolatilenoexcept;bool is_lock_free()constnoexcept; 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)volatilenoexcept;void store(/* floating-point */, memory_order = memory_order_seq_cst)noexcept;/* floating-point */ operator=(/* floating-point */)volatilenoexcept;/* floating-point */ operator=(/* floating-point */)noexcept;/* floating-point */ load(memory_order = memory_order_seq_cst)volatilenoexcept;/* floating-point */ load(memory_order = memory_order_seq_cst)noexcept; operator /* floating-point */()volatilenoexcept; operator /* floating-point */()noexcept; /* floating-point */ exchange(/* floating-point */, memory_order = memory_order_seq_cst)volatilenoexcept;/* floating-point */ exchange(/* floating-point */, memory_order = memory_order_seq_cst)noexcept;bool compare_exchange_weak(/* floating-point */&, /* floating-point */, memory_order, memory_order)volatilenoexcept;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)volatilenoexcept;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)volatilenoexcept;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)volatilenoexcept;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)volatilenoexcept;/* 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)volatilenoexcept;/* floating-point */ fetch_sub(/* floating-point */, memory_order = memory_order_seq_cst)noexcept; /* floating-point */ operator+=(/* floating-point */)volatilenoexcept;/* floating-point */ operator+=(/* floating-point */)noexcept;/* floating-point */ operator-=(/* floating-point */)volatilenoexcept;/* floating-point */ operator-=(/* floating-point */)noexcept; void wait(/* floating-point */, memory_order = memory_order::seq_cst)constvolatilenoexcept;void wait(/* floating-point */, memory_order = memory_order::seq_cst)constnoexcept;void notify_one()volatilenoexcept;void notify_one()noexcept;void notify_all()volatilenoexcept;void notify_all()noexcept;};}
[edit]Specializations of std::atomic for pointer types
namespace std {template<class T>struct atomic<T*>{using value_type = T*;using difference_type = ptrdiff_t; staticconstexprbool is_always_lock_free =/* implementation-defined */;bool is_lock_free()constvolatilenoexcept;bool is_lock_free()constnoexcept; 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)volatilenoexcept;void store(T*, memory_order = memory_order::seq_cst)noexcept; T* operator=(T*)volatilenoexcept; T* operator=(T*)noexcept; T* load(memory_order = memory_order::seq_cst)constvolatilenoexcept; T* load(memory_order = memory_order::seq_cst)constnoexcept; operator T*()constvolatilenoexcept; operator T*()constnoexcept; T* exchange(T*, memory_order = memory_order::seq_cst)volatilenoexcept; T* exchange(T*, memory_order = memory_order::seq_cst)noexcept;bool compare_exchange_weak(T*&, T*, memory_order, memory_order)volatilenoexcept;bool compare_exchange_weak(T*&, T*, memory_order, memory_order)noexcept;bool compare_exchange_strong(T*&, T*, memory_order, memory_order)volatilenoexcept;bool compare_exchange_strong(T*&, T*, memory_order, memory_order)noexcept;bool compare_exchange_weak(T*&, T*, memory_order = memory_order::seq_cst)volatilenoexcept;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)volatilenoexcept;bool compare_exchange_strong(T*&, T*, memory_order = memory_order::seq_cst)noexcept; T* fetch_add(ptrdiff_t, memory_order = memory_order::seq_cst)volatilenoexcept; T* fetch_add(ptrdiff_t, memory_order = memory_order::seq_cst)noexcept; T* fetch_sub(ptrdiff_t, memory_order = memory_order::seq_cst)volatilenoexcept; T* fetch_sub(ptrdiff_t, memory_order = memory_order::seq_cst)noexcept; T* fetch_max(T*, memory_order = memory_order::seq_cst)volatilenoexcept; T* fetch_max(T*, memory_order = memory_order::seq_cst)noexcept; T* fetch_min(T*, memory_order = memory_order::seq_cst)volatilenoexcept; T* fetch_min(T*, memory_order = memory_order::seq_cst)noexcept; T* operator++(int)volatilenoexcept; T* operator++(int)noexcept; T* operator--(int)volatilenoexcept; T* operator--(int)noexcept; T* operator++()volatilenoexcept; T* operator++()noexcept; T* operator--()volatilenoexcept; T* operator--()noexcept; T* operator+=(ptrdiff_t)volatilenoexcept; T* operator+=(ptrdiff_t)noexcept; T* operator-=(ptrdiff_t)volatilenoexcept; T* operator-=(ptrdiff_t)noexcept; void wait(T*, memory_order = memory_order::seq_cst)constvolatilenoexcept;void wait(T*, memory_order = memory_order::seq_cst)constnoexcept;void notify_one()volatilenoexcept;void notify_one()noexcept;void notify_all()volatilenoexcept;void notify_all()noexcept;};}
[edit]Class template std::atomic_ref
namespace std {template<class T>struct atomic_ref {private: T* ptr;// exposition onlypublic:using value_type = T;staticconstexpr size_t required_alignment =/* implementation-defined */; staticconstexprbool is_always_lock_free =/* implementation-defined */;bool is_lock_free()constnoexcept; 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)constnoexcept; T operator=(T)constnoexcept; T load(memory_order = memory_order_seq_cst)constnoexcept; operator T()constnoexcept; T exchange(T, memory_order = memory_order_seq_cst)constnoexcept;bool compare_exchange_weak(T&, T, memory_order, memory_order)constnoexcept;bool compare_exchange_strong(T&, T, memory_order, memory_order)constnoexcept;bool compare_exchange_weak(T&, T, memory_order = memory_order_seq_cst)constnoexcept;bool compare_exchange_strong(T&, T, memory_order = memory_order_seq_cst)constnoexcept; void wait(T, memory_order = memory_order::seq_cst)constnoexcept;void notify_one()constnoexcept;void notify_all()constnoexcept;};}
[edit]Specializations of std::atomic_ref for integral types
namespace std {template<>struct atomic_ref</* integral */>{private:/* integral */* ptr;// exposition onlypublic:using value_type =/* integral */;using difference_type = value_type;staticconstexpr size_t required_alignment =/* implementation-defined */; staticconstexprbool is_always_lock_free =/* implementation-defined */;bool is_lock_free()constnoexcept; 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)constnoexcept;/* integral */ operator=(/* integral */)constnoexcept;/* integral */ load(memory_order = memory_order_seq_cst)constnoexcept; operator /* integral */()constnoexcept; /* integral */ exchange(/* integral */, memory_order = memory_order_seq_cst)constnoexcept;bool compare_exchange_weak(/* integral */&, /* integral */, memory_order, memory_order)constnoexcept;bool compare_exchange_strong(/* integral */&, /* integral */, memory_order, memory_order)constnoexcept;bool compare_exchange_weak(/* integral */&, /* integral */, memory_order = memory_order_seq_cst)constnoexcept;bool compare_exchange_strong(/* integral */&, /* integral */, memory_order = memory_order_seq_cst)constnoexcept; /* integral */ fetch_add(/* integral */, memory_order = memory_order_seq_cst)constnoexcept;/* integral */ fetch_sub(/* integral */, memory_order = memory_order_seq_cst)constnoexcept;/* integral */ fetch_and(/* integral */, memory_order = memory_order_seq_cst)constnoexcept;/* integral */ fetch_or(/* integral */, memory_order = memory_order_seq_cst)constnoexcept;/* integral */ fetch_xor(/* integral */, memory_order = memory_order_seq_cst)constnoexcept;/* integral */ fetch_max(/* integral */, memory_order = memory_order_seq_cst)constnoexcept;/* integral */ fetch_min(/* integral */, memory_order = memory_order_seq_cst)constnoexcept; /* integral */ operator++(int)constnoexcept;/* integral */ operator--(int)constnoexcept;/* integral */ operator++()constnoexcept;/* integral */ operator--()constnoexcept;/* integral */ operator+=(/* integral */)constnoexcept;/* integral */ operator-=(/* integral */)constnoexcept;/* integral */ operator&=(/* integral */)constnoexcept;/* 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 onlypublic:using value_type =/* floating-point */;using difference_type = value_type;staticconstexpr size_t required_alignment =/* implementation-defined */; staticconstexprbool is_always_lock_free =/* implementation-defined */;bool is_lock_free()constnoexcept; 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)constnoexcept;/* floating-point */ operator=(/* floating-point */)constnoexcept;/* floating-point */ load(memory_order = memory_order_seq_cst)constnoexcept; operator /* floating-point */()constnoexcept; /* floating-point */ exchange(/* floating-point */, memory_order = memory_order_seq_cst)constnoexcept;bool compare_exchange_weak(/* floating-point */&, /* floating-point */, memory_order, memory_order)constnoexcept;bool compare_exchange_strong(/* floating-point */&, /* floating-point */, memory_order, memory_order)constnoexcept;bool compare_exchange_weak(/* floating-point */&, /* floating-point */, memory_order = memory_order_seq_cst)constnoexcept;bool compare_exchange_strong(/* floating-point */&, /* floating-point */, memory_order = memory_order_seq_cst)constnoexcept; /* floating-point */ fetch_add(/* floating-point */, memory_order = memory_order_seq_cst)constnoexcept;/* floating-point */ fetch_sub(/* floating-point */, memory_order = memory_order_seq_cst)constnoexcept; /* floating-point */ operator+=(/* floating-point */)constnoexcept;/* floating-point */ operator-=(/* floating-point */)constnoexcept; void wait(/* floating-point */, memory_order = memory_order::seq_cst)constnoexcept;void notify_one()constnoexcept;void notify_all()constnoexcept;};}
[edit]Specializations of std::atomic_ref for pointer types
namespace std {template<class T>struct atomic_ref<T*>{private: T** ptr;// exposition onlypublic:using value_type = T*;using difference_type = ptrdiff_t;staticconstexpr size_t required_alignment =/* implementation-defined */; staticconstexprbool is_always_lock_free =/* implementation-defined */;bool is_lock_free()constnoexcept; 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)constnoexcept; T* operator=(T*)constnoexcept; T* load(memory_order = memory_order_seq_cst)constnoexcept; operator T*()constnoexcept; T* exchange(T*, memory_order = memory_order_seq_cst)constnoexcept;bool compare_exchange_weak(T*&, T*, memory_order, memory_order)constnoexcept;bool compare_exchange_strong(T*&, T*, memory_order, memory_order)constnoexcept;bool compare_exchange_weak(T*&, T*, memory_order = memory_order_seq_cst)constnoexcept;bool compare_exchange_strong(T*&, T*, memory_order = memory_order_seq_cst)constnoexcept; T* fetch_add(difference_type, memory_order = memory_order_seq_cst)constnoexcept; T* fetch_sub(difference_type, memory_order = memory_order_seq_cst)constnoexcept; T* fetch_max(T *, memory_order = memory_order::seq_cst)constnoexcept; T* fetch_min(T *, memory_order = memory_order::seq_cst)constnoexcept; T* operator++(int)constnoexcept; T* operator--(int)constnoexcept; T* operator++()constnoexcept; T* operator--()constnoexcept; T* operator+=(difference_type)constnoexcept; T* operator-=(difference_type)constnoexcept; void wait(T*, memory_order = memory_order::seq_cst)constnoexcept;void notify_one()constnoexcept;void notify_all()constnoexcept;};}
[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)constvolatilenoexcept;bool test(memory_order = memory_order::seq_cst)constnoexcept;bool test_and_set(memory_order = memory_order::seq_cst)volatilenoexcept;bool test_and_set(memory_order = memory_order::seq_cst)noexcept;void clear(memory_order = memory_order::seq_cst)volatilenoexcept;void clear(memory_order = memory_order::seq_cst)noexcept; void wait(bool, memory_order = memory_order::seq_cst)constvolatilenoexcept;void wait(bool, memory_order = memory_order::seq_cst)constnoexcept;void notify_one()volatilenoexcept;void notify_one()noexcept;void notify_all()volatilenoexcept;void notify_all()noexcept;};}
