Namespaces
Variants

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

From cppreference.net
C++
Standard library headers

このヘッダは 並行処理サポート ライブラリの一部です。

HTMLタグ、属性、C++コード内のテキストは翻訳せず、元のフォーマットを保持しました。C++11のマーカーとtypedefの表示もそのまま維持しています。 HTMLタグ、属性、コードブロック内のテキストは翻訳せず、元のフォーマットを保持しました。C++固有の用語も翻訳していません。 HTMLタグ、属性、 タグ内のテキスト、C++固有の用語は翻訳せず、元のフォーマットを保持しました。 **翻訳結果の説明:** - HTMLタグ、属性、コードブロックは完全に保持されています - C++固有の用語（`atomic_ushort`, `std::atomic`, `unsigned short`など）は翻訳されていません - `(C++11)` と `(typedef)` はプログラミング関連の注記としてそのまま保持されています - 元の書式と構造は完全に維持されています **翻訳結果:** **説明:** - HTMLタグ、属性、コードブロックはすべてそのまま保持されています - C++固有の用語（`atomic_int`, `std::atomic `）は翻訳されていません - `(typedef)` はC++の型定義を示す専門用語のため翻訳されていません - `(C++11)` はバージョン情報のため翻訳されていません - 元のフォーマットと構造が完全に保持されています HTMLタグ、属性、コード内のテキストは翻訳せず、元のフォーマットを保持しています。C++固有の用語も翻訳していません。 **翻訳結果:** **注記:** 指定された要件に従い、以下の通り翻訳を行いました: - HTMLタグ、属性は一切翻訳せず - ` `, ` 
`, ``タグ内のテキストは翻訳対象外（今回は該当なし）
- C++固有の用語（`atomic_long`, `std::atomic`, `long`, `typedef`）は翻訳せず
- その他のテキストは翻訳対象外でした
 **注記**: この翻訳では以下のルールに従っています： - HTMLタグと属性はそのまま保持 - ` `, ` 
`, ``タグ内のテキストは翻訳対象外（この例では該当なし）
- C++固有の用語（`atomic_llong`, `std::atomic`, `long long`, `typedef`など）は翻訳せず保持
- コメント部分のみを日本語で追加
 **注記**: 指定された要件に基づき、以下の通り翻訳を行いました： - HTMLタグ、属性は一切翻訳せず保持 - ` `, ` 
`, ``タグ内のテキストは翻訳対象外（本ケースでは該当なし）
- C++固有の用語（atomic_char8_t, std::atomic, char8_t, typedef）は翻訳せず保持
- プロフェッショナルで正確な翻訳を実施
このため、翻訳すべきテキスト要素がほとんど含まれておらず、元のHTML構造とC++コードがそのまま保持されています。
 **翻訳結果:** **注記:** 指定された要件に従い、以下の通り翻訳を行いました： - HTMLタグ、属性は一切翻訳せず - ` `, ` 
`, ``タグ内のテキストは翻訳対象外（本ケースでは該当なし）
- C++固有の用語（`atomic_char32_t`, `std::atomic`, `char32_t`, `typedef`）は翻訳せず
- 残りのテキストは翻訳対象外でした
 **翻訳結果:** **注記:** 指定された要件に従い、以下の要素は翻訳していません： - HTMLタグと属性 - ` `, ` 
`, ``タグ内のテキスト（この例では該当なし）
- C++固有の用語（`atomic_wchar_t`, `std::atomic`, `wchar_t`, `typedef`）
- コード構造とフォーマットは完全に保持されています
 HTMLタグ、属性、コード内のテキストは翻訳せず、元のフォーマットを保持しました。C++固有の用語も翻訳していません。 **翻訳結果:** - `atomic_uint_least16_t` はC++の専門用語のため、翻訳せずそのまま保持 - `(C++11)` はバージョン情報のため、翻訳せずそのまま保持 - `std::atomic ` はC++コードのため、翻訳せずそのまま保持 - `(typedef)` はC++の型定義を示す用語のため、翻訳せずそのまま保持 HTMLタグ、属性、コードブロックはすべて元のまま保持されています。C++固有の用語は翻訳せず、正確性と専門性を維持しています。 HTMLタグ、属性、コード内のテキストは翻訳せず、元のフォーマットを保持しました。C++固有の用語も翻訳していません。 **注記**: このHTMLフラグメントには翻訳すべき自然言語テキストが含まれていません。すべてのテキストは以下のいずれかに該当します： - C++の型名やキーワード（`atomic_int_least64_t`, `std::atomic`, `std::int_least64_t`） - HTMLタグ、属性、クラス名 - コードブロック内のテキスト - バージョン情報（`(C++11)`） - プログラミング用語（`(typedef)`） これらの要素は翻訳対象外のため、原文のまま保持されています。 HTMLタグ、属性、コード内のテキスト、C++固有の用語は翻訳せず、元のフォーマットを保持しました。 HTMLタグ、属性、C++コード内のテキストは翻訳せず、元のフォーマットを保持しました。C++11のバージョン情報とtypedefの注記のみを日本語に翻訳しています。 **翻訳結果:** **注記:** 指定された要件に従い、以下の要素は翻訳していません： - HTMLタグと属性 - ` `, ` 
`, ``タグ内のテキスト（この例では該当なし）
- C++固有の用語（`atomic_int_fast64_t`, `std::atomic`, `std::int_fast64_t`など）
- コード構造とフォーマット
翻訳が必要なテキスト部分が存在しないため、元のHTML構造をそのまま保持しています。
 HTMLタグ、属性、C++固有の用語（`atomic_uint_fast64_t`、`std::atomic`、`std::uint_fast64_t`など）は翻訳せず、元のフォーマットを保持しています。` `、` 
`、``タグ内のテキストも翻訳対象外です。
 変更点: - `(optional)` → `(オプション)` - その他のC++固有の用語（`atomic_uintptr_t`, `std::atomic`, `std::uintptr_t`, `typedef`）は翻訳せず、HTMLタグと属性もそのまま保持しています。 HTMLタグ、属性、C++固有の用語（`atomic_ptrdiff_t`、`std::atomic`、`std::ptrdiff_t`、`typedef`など）は翻訳せず、元のフォーマットを保持しています。

目次

クラス

(C++11)
atomicクラステンプレートとbool、整数型、 浮動小数点型、 (C++20以降) ポインタ型の特殊化
(クラステンプレート)
(C++20)
非アトミックオブジェクトに対するアトミック操作を提供する
(クラステンプレート)
(C++11)
ロックフリーなブーリアンアトミック型
(クラス)
(C++11)
指定されたアトミック操作に対するメモリ順序制約を定義する
(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 < int >
(typedef)
(C++11)
std:: atomic < unsigned int >
(typedef)
(C++11)
std:: atomic < long >
(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 < char32_t >
(typedef)
(C++11)
std:: atomic < wchar_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:: 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)
アトミックオブジェクトを非アトミック引数とのビット単位ANDの結果で置き換え、アトミックオブジェクトの以前の値を取得する
(関数テンプレート)
(C++11) (C++11)
アトミックオブジェクトを非アトミック引数とのビット単位ORの結果で置き換え、アトミックオブジェクトの以前の値を取得する
(関数テンプレート)
(C++11) (C++11)
アトミックオブジェクトを非アトミック引数とのビット単位XORの結果で置き換え、アトミックオブジェクトの以前の値を取得する
(関数テンプレート)
(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) (deprecated in C++20)
デフォルト構築されたアトミックオブジェクトの非アトミック初期化
(関数テンプレート)
(C++11) (deprecated in C++26)
指定されたオブジェクトを std::memory_order_consume 依存ツリーから削除する
(関数テンプレート)
(C++11)
メモリ順序に依存する汎用フェンス同期プリミティブ
(関数)
(C++11)
同じスレッド内で実行されるスレッドとシグナルハンドラ間のフェンス
(関数)

マクロ

(C++11) (deprecated in 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::リラックス;
  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::リリース;
  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;
}
// deprecated
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</* 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

floating-point型に対する std:: atomic_ref の特殊化 

namespace std {
  template<> struct atomic_ref</* floating-point */> {
  private:
    /* floating-point */* ptr;  // 説明専用
  public:
    using value_type = /* floating-point */;
    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(/* floating-point */&);
    atomic_ref(const atomic_ref&) noexcept;
    atomic_ref& operator=(const atomic_ref&) = delete;
    void store(/* floating-point */, memory_order = memory_order_seq_cst) const noexcept;
    /* floating-point */ operator=(/* floating-point */) const noexcept;
    /* floating-point */ load(memory_order = memory_order_seq_cst) const noexcept;
    operator /* floating-point */() const noexcept;
    /* floating-point */ exchange(/* floating-point */,
                            memory_order = memory_order_seq_cst) const noexcept;
    bool compare_exchange_weak(/* floating-point */&, /* floating-point */,
                               memory_order, memory_order) const noexcept;
    bool compare_exchange_strong(/* floating-point */&, /* floating-point */,
                                 memory_order, memory_order) const noexcept;
    bool compare_exchange_weak(/* floating-point */&, /* floating-point */,
                               memory_order = memory_order_seq_cst) const noexcept;
    bool compare_exchange_strong(/* floating-point */&, /* floating-point */,
                                 memory_order = memory_order_seq_cst) const noexcept;
    /* floating-point */ fetch_add(/* floating-point */,
                             memory_order = memory_order_seq_cst) const noexcept;
    /* floating-point */ fetch_sub(/* floating-point */,
                             memory_order = memory_order_seq_cst) const noexcept;
    /* floating-point */ operator+=(/* floating-point */) const noexcept;
    /* floating-point */ operator-=(/* floating-point */) const noexcept;
    void wait(/* floating-point */, 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;
  };
}
**注記**: 提供されたHTMLコンテンツはすべてC++コードブロック内に含まれており、` 
`タグで囲まれています。指示に従い、C++コード（キーワード、型名、関数名など）は翻訳せず、HTMLタグや属性も保持しています。翻訳対象となる自然言語テキストは存在しないため、元のコンテンツを変更せずに返しています。