Namespaces
Variants

Standard library header <atomic> (C++11)

From cppreference.net
C++
Standard library headers

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

Contents

Classes

(C++11)
atomic class template and specializations for bool, integral, floating-point, (since C++20) and pointer types
(class template)
(C++20)
provides atomic operations on non-atomic objects
(class template)
(C++11)
the lock-free boolean atomic type
(class)
(C++11)
defines memory ordering constraints for the given atomic operation
(enum)
(C++11)
std:: atomic < bool >
(typedef)
(C++11)
std:: atomic < char >
(typedef)
(C++11)
std:: atomic < 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) (optional)
std:: atomic < std:: int8_t >
(typedef)
(C++11) (optional)
std:: atomic < std:: uint8_t >
(typedef)
(C++11) (optional)
std:: atomic < std:: int16_t >
(typedef)
(C++11) (optional)
std:: atomic < std:: uint16_t >
(typedef)
(C++11) (optional)
std:: atomic < std:: int32_t >
(typedef)
(C++11) (optional)
std:: atomic < std:: uint32_t >
(typedef)
(C++11) (optional)
std:: atomic < std:: int64_t >
(typedef)
(C++11) (optional)
std:: atomic < std:: uint64_t >
(typedef)
(C++11)
std:: atomic < std:: int_least8_t >
(typedef)
(C++11)
std:: atomic < std:: uint_least8_t >
(typedef)
(C++11)
std:: atomic < std:: int_least16_t >
(typedef)
(C++11)
std:: atomic < std:: uint_least16_t >
(typedef)
(C++11)
std:: atomic < std:: int_least32_t >
(typedef)
(C++11)
std:: atomic < std:: uint_least32_t >
(typedef)
(C++11)
std:: atomic < std:: int_least64_t >
(typedef)
(C++11)
std:: atomic < std:: uint_least64_t >
(typedef)
(C++11)
std:: atomic < std:: int_fast8_t >
(typedef)
(C++11)
std:: atomic < std:: uint_fast8_t >
(typedef)
(C++11)
std:: atomic < std:: int_fast16_t >
(typedef)
(C++11)
std:: atomic < std:: uint_fast16_t >
(typedef)
(C++11)
std:: atomic < std:: int_fast32_t >
(typedef)
(C++11)
std:: atomic < std:: uint_fast32_t >
(typedef)
(C++11)
std:: atomic < std:: int_fast64_t >
(typedef)
(C++11)
std:: atomic < std:: uint_fast64_t >
(typedef)
(C++11) (optional)
std:: atomic < std:: intptr_t >
(typedef)
(C++11) (optional)
std:: atomic < std:: uintptr_t >
(typedef)
(C++11)
std:: atomic < std:: size_t >
(typedef)
(C++11)
std:: atomic < std:: ptrdiff_t >
(typedef)
(C++11)
std:: atomic < std:: intmax_t >
(typedef)
(C++11)
std:: atomic < std:: uintmax_t >
(typedef)
(C++20)
a signed integral atomic type that is lock-free and for which waiting/notifying is most efficient
(typedef)
(C++20)
an unsigned integral atomic type that is lock-free and for which waiting/notifying is most efficient
(typedef)

Functions

(C++11)
checks if the atomic type's operations are lock-free
(function template)
(C++11) (C++11)
atomically replaces the value of the atomic object with a non-atomic argument
(function template)
(C++11) (C++11)
atomically obtains the value stored in an atomic object
(function template)
(C++11) (C++11)
atomically replaces the value of the atomic object with non-atomic argument and returns the old value of the atomic
(function template)
(C++11) (C++11) (C++11) (C++11)
atomically compares the value of the atomic object with non-atomic argument and performs atomic exchange if equal or atomic load if not
(function template)
(C++11) (C++11)
adds a non-atomic value to an atomic object and obtains the previous value of the atomic
(function template)
(C++11) (C++11)
subtracts a non-atomic value from an atomic object and obtains the previous value of the atomic
(function template)
(C++11) (C++11)
replaces the atomic object with the result of bitwise AND with a non-atomic argument and obtains the previous value of the atomic
(function template)
(C++11) (C++11)
replaces the atomic object with the result of bitwise OR with a non-atomic argument and obtains the previous value of the atomic
(function template)
(C++11) (C++11)
replaces the atomic object with the result of bitwise XOR with a non-atomic argument and obtains the previous value of the atomic
(function template)
(C++26) (C++26)
replaces the atomic object with the result of std::max with a non-atomic argument and obtains the previous value of the atomic
(function template)
(C++26) (C++26)
replaces the atomic object with the result of std::min with a non-atomic argument and obtains the previous value of the atomic
(function template)
(C++20) (C++20)
blocks the thread until notified and the atomic value changes
(function template)
(C++20)
notifies a thread blocked in atomic_wait
(function template)
(C++20)
notifies all threads blocked in atomic_wait
(function template)
(C++20) (C++20)
atomically returns the value of the flag
(function)
(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++20) (C++20)
blocks the thread until notified and the flag changes
(function)
(C++20)
notifies a thread blocked in atomic_flag_wait
(function)
(C++20)
notifies all threads blocked in atomic_flag_wait
(function)
(C++11) (deprecated in C++20)
non-atomic initialization of a default-constructed atomic object
(function template)
(C++11) (deprecated in C++26)
removes the specified object from the std::memory_order_consume dependency tree
(function template)
(C++11)
generic memory order-dependent fence synchronization primitive
(function)
(C++11)
fence between a thread and a signal handler executed in the same thread
(function)

Macros

(C++11) (deprecated in C++20)
constant initialization of an atomic variable of static storage duration
(function macro)
(C++11)
initializes an std::atomic_flag to false
(macro constant)

概要 

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<span

类模板 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</* integral */> {
    using value_type = /* integral */;
    using difference_type = value_type;
    static constexpr bool is_always_lock_free = /* implementation-defined */;
    bool is_lock_free() const volatile noexcept;
    bool is_lock_free() const noexcept;
    constexpr atomic() noexcept;
    constexpr atomic(/* integral */) noexcept;
    atomic(const atomic&) = delete;
    atomic& operator=(const atomic&) = delete;
    atomic& operator=(const atomic&) volatile = delete;
    void store(/* integral */, memory_order = memory_order::seq_cst) volatile noexcept;
    void store(/* integral */, memory_order = memory_order::seq_cst) noexcept;
    /* integral */ operator=(/* integral */) volatile noexcept;
    /* integral */ operator=(/* integral */) noexcept;
    /* integral */ load(memory_order = memory_order::seq_cst) const volatile noexcept;
    /* integral */ load(memory_order = memory_order::seq_cst) const noexcept;
    operator /* integral */() const volatile noexcept;
    operator /* integral */() const noexcept;
    /* integral */ exchange(/* integral */,
                        memory_order = memory_order::seq_cst) volatile noexcept;
    /* integral */ exchange(/* integral */,
                        memory_order = memory_order::seq_cst) noexcept;
    bool compare_exchange_weak(/* integral */&, /* integral */,
                               memory_order, memory_order) volatile noexcept;
    bool compare_exchange_weak(/* integral */&, /* integral */,
                               memory_order, memory_order) noexcept;
    bool compare_exchange_strong(/* integral */&, /* integral */,
                                 memory_order, memory_order) volatile noexcept;
    bool compare_exchange_strong(/* integral */&, /* integral */,
                                 memory_order, memory_order) noexcept;
    bool compare_exchange_weak(/* integral */&, /* integral */,
                               memory_order = memory_order::seq_cst) volatile noexcept;
    bool compare_exchange_weak(/* integral */&, /* integral */,
                               memory_order = memory_order::seq_cst) noexcept;
    bool compare_exchange_strong(/* integral */&, /* integral */,
                                 memory_order = memory_order::seq_cst) volatile noexcept;
    bool compare_exchange_strong(/* integral */&, /* integral */,
                                 memory_order = memory_order::seq_cst) noexcept;
    /* integral */ fetch_add(/* integral */,
                         memory_order = memory_order::seq_cst) volatile noexcept;
    /* integral */ fetch_add(/* integral */,
                         memory_order = memory_order::seq_cst) noexcept;
    /* integral */ fetch_sub(/* integral */,
                         memory_order = memory_order::seq_cst) volatile noexcept;
    /* integral */ fetch_sub(/* integral */,
                         memory_order = memory_order::seq_cst) noexcept;
    /* integral */ fetch_and(/* integral */,
                         memory_order = memory_order::seq_cst) volatile noexcept;
    /* integral */ fetch_and(/* integral */,
                         memory_order = memory_order::seq_cst) noexcept;
    /* integral */ fetch_or(/* integral */,
                         memory_order = memory_order::seq_cst) volatile noexcept;
    /* integral */ fetch_or(/* integral */,
                         memory_order = memory_order::seq_cst) noexcept;
    /* integral */ fetch_xor(/* integral */,
                         memory_order = memory_order::seq_cst) volatile noexcept;
    /* integral */ fetch_xor(/* integral */,
                         memory_order = memory_order::seq_cst) noexcept;
    /* integral */ fetch_max(/* integral */,
                         memory_order = memory_order::seq_cst) volatile noexcept;
    /* integral */

浮点类型的 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

类模板 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</* integral */> {
  private:
    /* integral */* ptr;        // 仅用于说明
  public:
    using value_type = /* integral */;
    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(/* integral */&);
    atomic_ref(const atomic_ref&) noexcept;
    atomic_ref& operator=(const atomic_ref&) = delete;
    void store(/* integral */, memory_order = memory_order_seq_cst) const noexcept;
    /* integral */ operator=(/* integral */) const noexcept;
    /* integral */ load(memory_order = memory_order_seq_cst) const noexcept;
    operator /* integral */() const noexcept;
    /* integral */ exchange(/* integral */,
                      memory_order = memory_order_seq_cst) const noexcept;
    bool compare_exchange_weak(/* integral */&, /* integral */,
                               memory_order, memory_order) const noexcept;
    bool compare_exchange_strong(/* integral */&, /* integral */,
                                 memory_order, memory_order) const noexcept;
    bool compare_exchange_weak(/* integral */&, /* integral */,
                               memory_order = memory_order_seq_cst) const noexcept;
    bool compare_exchange_strong(/* integral */&, /* integral */,
                                 memory_order = memory_order_seq_cst) const noexcept;
    /* integral */ fetch_add(/* integral */,
                       memory_order = memory_order_seq_cst) const noexcept;
    /* integral */ fetch_sub(/* integral */,
                       memory_order = memory_order_seq_cst) const noexcept;
    /* integral */ fetch_and(/* integral */,
                       memory_order = memory_order_seq_cst) const noexcept;
    /* integral */ fetch_or(/* integral */,
                      memory_order = memory_order_seq_cst) const noexcept;
    /* integral */ fetch_xor(/* integral */,
                       memory_order = memory_order_seq_cst) const noexcept;
    /* integral */ fetch_max(/* integral */,
                       memory_order = memory_order_seq_cst) const noexcept;
    /* integral */ fetch_min(/* integral */,
                       memory_order = memory_order_seq_cst) const noexcept;
    /* integral */ operator++(int) const noexcept;
    /* integral */ operator--(int) const noexcept;
    /* integral */ operator++() const noexcept;
    /* integral */ operator--() const noexcept;
    /* integral */ operator+=(/* integral */) const noexcept;
    /* integral */ operator-=(/* integral */) const noexcept;
    /* integral */ operator&=(/* integral */) const noexcept;
    /* integral */ operator

针对浮点类型的 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;
  };
}