标准库标头 <atomic> (C++11)

来自cppreference.com
See More


 
C++
 
标准库头
通用工具
<any> (C++17)
<bitset>
<bit> (C++20)
<charconv> (C++17)
<expected> (C++23)
<format> (C++20)
<functional>
<optional> (C++17)
<stdbit.h> (C++26)
<tuple> (C++11)
<typeindex> (C++11)
<utility>
<variant> (C++17)
容器
<array> (C++11)
<deque>
<flat_map> (C++23)
<flat_set> (C++23)
<forward_list> (C++11)
<hive> (C++26)
<inplace_vector> (C++26)   
<list>
<map>
<mdspan> (C++23)
<queue>
<set>
<span> (C++20)
<stack>
<unordered_map> (C++11)
<unordered_set> (C++11)
<vector>
迭代器
<iterator>
范围
<generator> (C++23)
<ranges> (C++20)
 

此头文件是并发支持库的一部分。

类

(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++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)
 原子地返回标志的值
(函数) [编辑]
(C++11)(C++11)
 原子地设置标志为 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)(C++26 弃用)
 从 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;
  };
}