This header is part of the atomic operations library.
Classes | |
| (C++11) | atomic class template and specializations for bool, integral, and pointer types (class template) |
| (C++11) | the lock-free boolean atomic type (class) |
| (C++11) | defines memory ordering constraints for the given atomic operation (typedef) |
Typedefs | |
std::atomic_bool | std::atomic<bool> |
std::atomic_char | std::atomic<char> |
std::atomic_schar | std::atomic<signed char> |
std::atomic_uchar | std::atomic<unsigned char> |
std::atomic_short | std::atomic<short> |
std::atomic_ushort | std::atomic<unsigned short> |
std::atomic_int | std::atomic<int> |
std::atomic_uint | std::atomic<unsigned int> |
std::atomic_long | std::atomic<long> |
std::atomic_ulong | std::atomic<unsigned long> |
std::atomic_llong | std::atomic<long long> |
std::atomic_ullong | std::atomic<unsigned long long> |
std::atomic_char16_t | std::atomic<char16_t> |
std::atomic_char32_t | std::atomic<char32_t> |
std::atomic_wchar_t | std::atomic<wchar_t> |
std::atomic_int_least8_t | std::atomic<int_least8_t> |
std::atomic_uint_least8_t | std::atomic<uint_least8_t> |
std::atomic_int_least16_t | std::atomic<int_least16_t> |
std::atomic_uint_least16_t | std::atomic<uint_least16_t> |
std::atomic_int_least32_t | std::atomic<int_least32_t> |
std::atomic_uint_least32_t | std::atomic<uint_least32_t> |
std::atomic_int_least64_t | std::atomic<int_least64_t> |
std::atomic_uint_least64_t | std::atomic<uint_least64_t> |
std::atomic_int_fast8_t | std::atomic<int_fast8_t> |
std::atomic_uint_fast8_t | std::atomic<uint_fast8_t> |
std::atomic_int_fast16_t | std::atomic<int_fast16_t> |
std::atomic_uint_fast16_t | std::atomic<uint_fast16_t> |
std::atomic_int_fast32_t | std::atomic<int_fast32_t> |
std::atomic_uint_fast32_t | std::atomic<uint_fast32_t> |
std::atomic_int_fast64_t | std::atomic<int_fast64_t> |
std::atomic_uint_fast64_t | std::atomic<uint_fast64_t> |
std::atomic_intptr_t | std::atomic<intptr_t> |
std::atomic_uintptr_t | std::atomic<uintptr_t> |
std::atomic_size_t | std::atomic<size_t> |
std::atomic_ptrdiff_t | std::atomic<ptrdiff_t> |
std::atomic_intmax_t | std::atomic<intmax_t> |
std::atomic_uintmax_t | std::atomic<uintmax_t> |
Functions | |
| (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 logical 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 logical 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 logical XOR with a non-atomic argument and obtains the previous value of the atomic (function template) |
| (C++11)(C++11) | 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++11) | non-atomic initialization of a default-constructed atomic object (function template) |
| (C++11) | 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) |
Preprocessor macros | |
| (C++11) | constant initialization of an atomic variable of static storage duration (function macro) |
| (C++11) | initializes an std::atomic_flag to false (macro constant) |
Synopsis
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 | 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
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 | 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
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 | 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
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 | 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
1 2 3 4 5 6 7 8 9 10 | 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; |
Please login to continue.