标准库标头 <atomic> (C++11)
来自cppreference.com
此头文件是并发支持库的一部分。
类 | |
(C++11) |
atomic 类模板及其针对布尔、整数、浮点数 (C++20 起)和指针类型的特化 (类模板) |
(C++20) |
提供非原子对象上的原子操作 (类模板) |
(C++11) |
免锁的布尔原子类型 (类) |
(C++11) |
为给定的原子操作定义内存定序约束 (枚举) |
(C++11) |
std::atomic<bool> (typedef) |
(C++11) |
std::atomic<char> (typedef) |
(C++11) |
std::atomic<signed char> (typedef) |
(C++11) |
std::atomic<unsigned char> (typedef) |
(C++11) |
std::atomic<short> (typedef) |
(C++11) |
std::atomic<unsigned short> (typedef) |
(C++11) |
std::atomic<int> (typedef) |
(C++11) |
std::atomic<unsigned int> (typedef) |
(C++11) |
std::atomic<long> (typedef) |
(C++11) |
std::atomic<unsigned long> (typedef) |
(C++11) |
std::atomic<long long> (typedef) |
(C++11) |
std::atomic<unsigned long long> (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)(可选) |
std::atomic<std::int8_t> (typedef) |
(C++11)(可选) |
std::atomic<std::uint8_t> (typedef) |
(C++11)(可选) |
std::atomic<std::int16_t> (typedef) |
(C++11)(可选) |
std::atomic<std::uint16_t> (typedef) |
(C++11)(可选) |
std::atomic<std::int32_t> (typedef) |
(C++11)(可选) |
std::atomic<std::uint32_t> (typedef) |
(C++11)(可选) |
std::atomic<std::int64_t> (typedef) |
(C++11)(可选) |
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)(可选) |
std::atomic<std::intptr_t> (typedef) |
(C++11)(可选) |
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) |
免锁且对于等待/提醒最高效的有符号整数原子类型 (typedef) |
(C++20) |
免锁且对于等待/提醒最高效的无符号整数原子类型 (typedef) |
函数 | |
(C++11) |
检查该原子类型的操作是否是免锁的 (函数模板) |
(C++11)(C++11) |
原子地以非原子实参替换原子对象的值 (函数模板) |
(C++11)(C++11) |
原子地获得存储于原子对象的值 (函数模板) |
(C++11)(C++11) |
原子地以非原子实参的值替换原子对象的值,并返回该原子对象的旧值 (函数模板) |
原子地比较原子对象和非原子实参的值,相等时进行原子交换,不相等时进行原子加载 (函数模板) | |
(C++11)(C++11) |
将非原子值加到原子对象上,并获得原子对象的先前值 (函数模板) |
(C++11)(C++11) |
从原子对象中减去非原子值,并获得原子对象的先前值 (函数模板) |
(C++11)(C++11) |
将原子对象替换为与非原子实参逐位与的结果,并获得原子对象的先前值 (函数模板) |
(C++11)(C++11) |
将原子对象替换为与非原子实参逐位或的结果,并获得原子对象的先前值 (函数模板) |
(C++11)(C++11) |
将原子对象替换为与非原子实参逐位异或的结果,并获得原子对象的先前值 (函数模板) |
(C++26)(C++26) |
将原子对象替换为与非原子实参的 std::max 的结果,并获得原子对象的先前值 (函数模板) |
(C++26)(C++26) |
将原子对象替换为与非原子实参的 std::min 的结果,并获得原子对象的先前值 (函数模板) |
(C++20)(C++20) |
阻塞线程直至被提醒且原子值更改 (函数模板) |
(C++20) |
提醒一个在 atomic_wait 中阻塞的线程 (函数模板) |
(C++20) |
提醒所有在 atomic_wait 中阻塞的线程 (函数模板) |
(C++20)(C++20) |
原子地返回标志的值 (函数) |
原子地设置标志为 true 并返回其先前值 (函数) | |
(C++11)(C++11) |
原子地设置标志值为 false (函数) |
(C++20)(C++20) |
阻塞线程,直至被提醒且标志更改 (函数) |
(C++20) |
提醒一个在 atomic_flag_wait 中阻塞的线程 (函数) |
(C++20) |
提醒所有在 atomic_flag_wait 中阻塞的线程 (函数) |
(C++11)(C++20 中弃用) |
对默认构造的原子对象进行非原子初始化 (函数模板) |
(C++11) |
从 std::memory_order_consume 依赖树移除指定对象 (函数模板) |
(C++11) |
通用的依赖内存定序的栅栏同步原语 (函数) |
(C++11) |
线程与执行于同一线程的信号处理函数间的栅栏 (函数) |
宏 | |
(C++11)(C++20 中弃用) |
静态存储期的原子变量的常量初始化 (宏函数) |
(C++11) |
将 std::atomic_flag 初始化为 false (宏常量) |
概要
namespace std { /* 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 : /* 未指定 */; 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<class T> T kill_dependency(T y) noexcept; // 免锁属性 #define ATOMIC_BOOL_LOCK_FREE /* 未指定 */ #define ATOMIC_CHAR_LOCK_FREE /* 未指定 */ #define ATOMIC_CHAR8_T_LOCK_FREE /* 未指定 */ #define ATOMIC_CHAR16_T_LOCK_FREE /* 未指定 */ #define ATOMIC_CHAR32_T_LOCK_FREE /* 未指定 */ #define ATOMIC_WCHAR_T_LOCK_FREE /* 未指定 */ #define ATOMIC_SHORT_LOCK_FREE /* 未指定 */ #define ATOMIC_INT_LOCK_FREE /* 未指定 */ #define ATOMIC_LONG_LOCK_FREE /* 未指定 */ #define ATOMIC_LLONG_LOCK_FREE /* 未指定 */ #define ATOMIC_POINTER_LOCK_FREE /* 未指定 */ // 类模板 atomic_ref template<class T> struct atomic_ref; // 对指针的部分特化 template<class T> struct atomic_ref<T*>; // 类模板 atomic template<class T> struct atomic; // 对指针的部分特化 template<class T> struct atomic<T*>; // 非成员函数 template<class T> bool atomic_is_lock_free(const volatile 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(const volatile atomic<T>*) noexcept; template<class T> T atomic_load(const atomic<T>*) noexcept; template<class T> T atomic_load_explicit(const volatile 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(const volatile 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(const volatile 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>*); // 类型别名 using atomic_bool = atomic<bool>; using atomic_char = atomic<char>; using atomic_schar = atomic<signed char>; using atomic_uchar = atomic<unsigned char>; using atomic_short = atomic<short>; using atomic_ushort = atomic<unsigned short>; using atomic_int = atomic<int>; using atomic_uint = atomic<unsigned int>; using atomic_long = atomic<long>; using atomic_ulong = atomic<unsigned long>; using atomic_llong = atomic<long long>; using atomic_ullong = atomic<unsigned long long>; 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 = /* 见描述 */; using atomic_unsigned_lock_free = /* 见描述 */; // 标志类型与操作 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; // 栅栏 extern "C" void atomic_thread_fence(memory_order) noexcept; extern "C" void atomic_signal_fence(memory_order) noexcept; } // 已弃用 namespace 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) /* 见描述 */ #define ATOMIC_FLAG_INIT /* 见描述 */ }
类模板 std::atomic
namespace std { template<class T> struct atomic { using value_type = T; static constexpr bool is_always_lock_free = /* 由实现定义 */; bool is_lock_free() const volatile noexcept; bool is_lock_free() const noexcept; // 原子类型上的操作 constexpr 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) 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; }; }
std::atomic 对整数类型的特化
namespace std { template<> struct atomic</* 整数 */> { using value_type = /* 整数 */; using difference_type = value_type; static constexpr bool is_always_lock_free = /* 由实现定义 */; bool is_lock_free() const volatile noexcept; bool is_lock_free() const noexcept; constexpr atomic() noexcept; constexpr atomic(/* 整数 */) noexcept; atomic(const atomic&) = delete; atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; void store(/* 整数 */, memory_order = memory_order::seq_cst) volatile noexcept; void store(/* 整数 */, memory_order = memory_order::seq_cst) noexcept; /* 整数 */ operator=(/* 整数 */) volatile noexcept; /* 整数 */ operator=(/* 整数 */) noexcept; /* 整数 */ load(memory_order = memory_order::seq_cst) const volatile noexcept; /* 整数 */ load(memory_order = memory_order::seq_cst) const noexcept; operator /* 整数 */() const volatile noexcept; operator /* 整数 */() const noexcept; /* 整数 */ exchange(/* 整数 */, memory_order = memory_order::seq_cst) volatile noexcept; /* 整数 */ exchange(/* 整数 */, memory_order = memory_order::seq_cst) noexcept; bool compare_exchange_weak(/* 整数 */&, /* 整数 */, memory_order, memory_order) volatile noexcept; bool compare_exchange_weak(/* 整数 */&, /* 整数 */, memory_order, memory_order) noexcept; bool compare_exchange_strong(/* 整数 */&, /* 整数 */, memory_order, memory_order) volatile noexcept; bool compare_exchange_strong(/* 整数 */&, /* 整数 */, memory_order, memory_order) noexcept; bool compare_exchange_weak(/* 整数 */&, /* 整数 */, memory_order = memory_order::seq_cst) volatile noexcept; bool compare_exchange_weak(/* 整数 */&, /* 整数 */, memory_order = memory_order::seq_cst) noexcept; bool compare_exchange_strong(/* 整数 */&, /* 整数 */, memory_order = memory_order::seq_cst) volatile noexcept; bool compare_exchange_strong(/* 整数 */&, /* 整数 */, memory_order = memory_order::seq_cst) noexcept; /* 整数 */ fetch_add(/* 整数 */, memory_order = memory_order::seq_cst) volatile noexcept; /* 整数 */ fetch_add(/* 整数 */, memory_order = memory_order::seq_cst) noexcept; /* 整数 */ fetch_sub(/* 整数 */, memory_order = memory_order::seq_cst) volatile noexcept; /* 整数 */ fetch_sub(/* 整数 */, memory_order = memory_order::seq_cst) noexcept; /* 整数 */ fetch_and(/* 整数 */, memory_order = memory_order::seq_cst) volatile noexcept; /* 整数 */ fetch_and(/* 整数 */, memory_order = memory_order::seq_cst) noexcept; /* 整数 */ fetch_or(/* 整数 */, memory_order = memory_order::seq_cst) volatile noexcept; /* 整数 */ fetch_or(/* 整数 */, memory_order = memory_order::seq_cst) noexcept; /* 整数 */ fetch_xor(/* 整数 */, memory_order = memory_order::seq_cst) volatile noexcept; /* 整数 */ fetch_xor(/* 整数 */, memory_order = memory_order::seq_cst) noexcept; /* 整数 */ fetch_max(/* 整数 */, memory_order = memory_order::seq_cst) volatile noexcept; /* 整数 */ fetch_max(/* 整数 */, memory_order = memory_order::seq_cst) noexcept; /* 整数 */ fetch_min(/* 整数 */, memory_order = memory_order::seq_cst) volatile noexcept; /* 整数 */ fetch_min(/* 整数 */, memory_order = memory_order::seq_cst) noexcept; /* 整数 */ operator++(int) volatile noexcept; /* 整数 */ operator++(int) noexcept; /* 整数 */ operator--(int) volatile noexcept; /* 整数 */ operator--(int) noexcept; /* 整数 */ operator++() volatile noexcept; /* 整数 */ operator++() noexcept; /* 整数 */ operator--() volatile noexcept; /* 整数 */ operator--() noexcept; /* 整数 */ operator+=(/* 整数 */) volatile noexcept; /* 整数 */ operator+=(/* 整数 */) noexcept; /* 整数 */ operator-=(/* 整数 */) volatile noexcept; /* 整数 */ operator-=(/* 整数 */) noexcept; /* 整数 */ operator&=(/* 整数 */) volatile noexcept; /* 整数 */ operator&=(/* 整数 */) noexcept; /* 整数 */ operator|=(/* 整数 */) volatile noexcept; /* 整数 */ operator|=(/* 整数 */) noexcept; /* 整数 */ operator^=(/* 整数 */) volatile noexcept; /* 整数 */ operator^=(/* 整数 */) noexcept; void wait(/* 整数 */, memory_order = memory_order::seq_cst) const volatile noexcept; void wait(/* 整数 */, 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; }; }
std::atomic 对浮点类型的特化
namespace std { template<> struct atomic</* 浮点数 */> { using value_type = /* 浮点数 */; using difference_type = value_type; static constexpr bool is_always_lock_free = /* 由实现定义 */; bool is_lock_free() const volatile noexcept; bool is_lock_free() const noexcept; constexpr atomic() noexcept; constexpr atomic(/* 浮点数 */) noexcept; atomic(const atomic&) = delete; atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; void store(/* 浮点数 */, memory_order = memory_order_seq_cst) volatile noexcept; void store(/* 浮点数 */, memory_order = memory_order_seq_cst) noexcept; /* 浮点数 */ operator=(/* 浮点数 */) volatile noexcept; /* 浮点数 */ operator=(/* 浮点数 */) noexcept; /* 浮点数 */ load(memory_order = memory_order_seq_cst) volatile noexcept; /* 浮点数 */ load(memory_order = memory_order_seq_cst) noexcept; operator /* 浮点数 */() volatile noexcept; operator /* 浮点数 */() noexcept; /* 浮点数 */ exchange(/* 浮点数 */, memory_order = memory_order_seq_cst) volatile noexcept; /* 浮点数 */ exchange(/* 浮点数 */, memory_order = memory_order_seq_cst) noexcept; bool compare_exchange_weak(/* 浮点数 */&, /* 浮点数 */, memory_order, memory_order) volatile noexcept; bool compare_exchange_weak(/* 浮点数 */&, /* 浮点数 */, memory_order, memory_order) noexcept; bool compare_exchange_strong(/* 浮点数 */&, /* 浮点数 */, memory_order, memory_order) volatile noexcept; bool compare_exchange_strong(/* 浮点数 */&, /* 浮点数 */, memory_order, memory_order) noexcept; bool compare_exchange_weak(/* 浮点数 */&, /* 浮点数 */, memory_order = memory_order_seq_cst) volatile noexcept; bool compare_exchange_weak(/* 浮点数 */&, /* 浮点数 */, memory_order = memory_order_seq_cst) noexcept; bool compare_exchange_strong(/* 浮点数 */&, /* 浮点数 */, memory_order = memory_order_seq_cst) volatile noexcept; bool compare_exchange_strong(/* 浮点数 */&, /* 浮点数 */, memory_order = memory_order_seq_cst) noexcept; /* 浮点数 */ fetch_add(/* 浮点数 */, memory_order = memory_order_seq_cst) volatile noexcept; /* 浮点数 */ fetch_add(/* 浮点数 */, memory_order = memory_order_seq_cst) noexcept; /* 浮点数 */ fetch_sub(/* 浮点数 */, memory_order = memory_order_seq_cst) volatile noexcept; /* 浮点数 */ fetch_sub(/* 浮点数 */, memory_order = memory_order_seq_cst) noexcept; /* 浮点数 */ operator+=(/* 浮点数 */) volatile noexcept; /* 浮点数 */ operator+=(/* 浮点数 */) noexcept; /* 浮点数 */ operator-=(/* 浮点数 */) volatile noexcept; /* 浮点数 */ operator-=(/* 浮点数 */) noexcept; void wait(/* 浮点数 */, memory_order = memory_order::seq_cst) const volatile noexcept; void wait(/* 浮点数 */, 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; }; }
std::atomic 对指针类型的特化
namespace std { template<class T> struct atomic<T*> { using value_type = T*; using difference_type = ptrdiff_t; static constexpr bool is_always_lock_free = /* 由实现定义 */; 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; }; }
类模板 std::atomic_ref
namespace std { template<class T> struct atomic_ref { private: T* ptr; // 仅用于阐述 public: using value_type = T; static constexpr size_t required_alignment = /* 由实现定义 */; static constexpr bool is_always_lock_free = /* 由实现定义 */; 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; }; }
std::atomic_ref 对整数类型的特化
namespace std { template<> struct atomic_ref</* 整数 */> { private: /* 整数 */* ptr; // 仅用于阐述 public: using value_type = /* 整数 */; using difference_type = value_type; static constexpr size_t required_alignment = /* 由实现定义 */; static constexpr bool is_always_lock_free = /* 由实现定义 */; bool is_lock_free() const noexcept; explicit atomic_ref(/* 整数 */&); atomic_ref(const atomic_ref&) noexcept; atomic_ref& operator=(const atomic_ref&) = delete; void store(/* 整数 */, memory_order = memory_order_seq_cst) const noexcept; /* 整数 */ operator=(/* 整数 */) const noexcept; /* 整数 */ load(memory_order = memory_order_seq_cst) const noexcept; operator /* 整数 */() const noexcept; /* 整数 */ exchange(/* 整数 */, memory_order = memory_order_seq_cst) const noexcept; bool compare_exchange_weak(/* 整数 */&, /* 整数 */, memory_order, memory_order) const noexcept; bool compare_exchange_strong(/* 整数 */&, /* 整数 */, memory_order, memory_order) const noexcept; bool compare_exchange_weak(/* 整数 */&, /* 整数 */, memory_order = memory_order_seq_cst) const noexcept; bool compare_exchange_strong(/* 整数 */&, /* 整数 */, memory_order = memory_order_seq_cst) const noexcept; /* 整数 */ fetch_add(/* 整数 */, memory_order = memory_order_seq_cst) const noexcept; /* 整数 */ fetch_sub(/* 整数 */, memory_order = memory_order_seq_cst) const noexcept; /* 整数 */ fetch_and(/* 整数 */, memory_order = memory_order_seq_cst) const noexcept; /* 整数 */ fetch_or(/* 整数 */, memory_order = memory_order_seq_cst) const noexcept; /* 整数 */ fetch_xor(/* 整数 */, memory_order = memory_order_seq_cst) const noexcept; /* 整数 */ fetch_max(/* 整数 */, memory_order = memory_order_seq_cst) const noexcept; /* 整数 */ fetch_min(/* 整数 */, memory_order = memory_order_seq_cst) const noexcept; /* 整数 */ operator++(int) const noexcept; /* 整数 */ operator--(int) const noexcept; /* 整数 */ operator++() const noexcept; /* 整数 */ operator--() const noexcept; /* 整数 */ operator+=(/* 整数 */) const noexcept; /* 整数 */ operator-=(/* 整数 */) const noexcept; /* 整数 */ operator&=(/* 整数 */) const noexcept; /* 整数 */ operator
std::atomic_ref 对浮点类型的特化
namespace std { template<> struct atomic_ref</* 浮点数 */> { private: /* 浮点数 */* ptr; // 仅用于阐述 public: using value_type = /* 浮点数 */; using difference_type = value_type; static constexpr size_t required_alignment = /* 由实现定义 */; static constexpr bool is_always_lock_free = /* 由实现定义 */; bool is_lock_free() const noexcept; explicit atomic_ref(/* 浮点数 */&); atomic_ref(const atomic_ref&) noexcept; atomic_ref& operator=(const atomic_ref&) = delete; void store(/* 浮点数 */, memory_order = memory_order_seq_cst) const noexcept; /* 浮点数 */ operator=(/* 浮点数 */) const noexcept; /* 浮点数 */ load(memory_order = memory_order_seq_cst) const noexcept; operator /* 浮点数 */() const noexcept; /* 浮点数 */ exchange(/* 浮点数 */, memory_order = memory_order_seq_cst) const noexcept; bool compare_exchange_weak(/* 浮点数 */&, /* 浮点数 */, memory_order, memory_order) const noexcept; bool compare_exchange_strong(/* 浮点数 */&, /* 浮点数 */, memory_order, memory_order) const noexcept; bool compare_exchange_weak(/* 浮点数 */&, /* 浮点数 */, memory_order = memory_order_seq_cst) const noexcept; bool compare_exchange_strong(/* 浮点数 */&, /* 浮点数 */, memory_order = memory_order_seq_cst) const noexcept; /* 浮点数 */ fetch_add(/* 浮点数 */, memory_order = memory_order_seq_cst) const noexcept; /* 浮点数 */ fetch_sub(/* 浮点数 */, memory_order = memory_order_seq_cst) const noexcept; /* 浮点数 */ operator+=(/* 浮点数 */) const noexcept; /* 浮点数 */ operator-=(/* 浮点数 */) const noexcept; void wait(/* 浮点数 */, memory_order = memory_order::seq_cst) const noexcept; void notify_one() const noexcept; void notify_all() const noexcept; }; }
std::atomic_ref 对指针类型的特化
namespace std { template<class T> struct atomic_ref<T*> { private: T** ptr; // 仅用于阐述 public: using value_type = T*; using difference_type = ptrdiff_t; static constexpr size_t required_alignment = /* 由实现定义 */; static constexpr bool is_always_lock_free = /* 由实现定义 */; 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; }; }
类 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; }; }