標準ライブラリヘッダ <atomic>

 

C++

言語

標準ライブラリヘッダ

フリースタンディング処理系とホスト処理系

名前付き要件

言語サポートライブラリ

コンセプトライブラリ (C++20)

診断ライブラリ

ユーティリティライブラリ

文字列ライブラリ

コンテナライブラリ

イテレータライブラリ

範囲ライブラリ (C++20)

アルゴリズムライブラリ

数値演算ライブラリ

入出力ライブラリ

ローカライゼーションライブラリ

正規表現ライブラリ (C++11)

アトミック操作ライブラリ (C++11)

スレッドサポートライブラリ (C++11)

ファイルシステムライブラリ (C++17)

技術仕様書

 

標準ライブラリヘッダ

言語サポート
<cstddef> <limits> <climits> <coroutine>	<cfloat> <cstdint> <new> <source_location>	<typeinfo> <exception> <initializer_list> <version>	<csignal> <csetjmp> <cstdarg>
コンセプト
<concepts>
診断
<stdexcept>	<cassert>	<cerrno>	<system_error>
汎用ユーティリティ
<utility> <memory> <memory_resource> <scoped_allocator>     <compare>	<bitset> <tuple> <optional> <any> <variant>	<type_traits> <ratio> <chrono> <typeindex> <functional>	<ctime> <cstdlib>
文字列
<string> <string_view> <cstring>	<charconv> <format>	<cctype> <cwctype>	<cwchar> <cuchar>
ローカライゼーション
<locale>	<codecvt>	<clocale>
コンテナ
<span> <array> <vector>	<deque> <forward_list> <list>	<map> <set> <queue>	<unordered_map> <unordered_set> <stack>
イテレータ
<iterator>
範囲
<ranges>
アルゴリズム
<algorithm>	<execution>
数値演算
<complex> <random>	<valarray> <numeric>	<bit> <numbers>	<cfenv> <cmath>
入出力
<iosfwd> <ios> <iomanip> <streambuf>	<istream> <ostream> <iostream>	<sstream> <fstream> <syncstream>	<cstdio> <cinttypes> <strstream>
正規表現
<regex>
ファイルシステムサポート
<filesystem>
スレッドサポート
<thread> <atomic> <mutex>	<shared_mutex> <condition_variable> <future>	<stop_token> <semaphore>	<latch> <barrier>
C互換
<ciso646> <cstdalign>	<cstdbool> <ccomplex>	<ctgmath>

 

このヘッダはアトミック操作ライブラリの一部です。

クラス
atomic (C++11)	atomic クラステンプレートと bool 型、整数型、ポインタ型に対する特殊化 (クラステンプレート)
atomic_ref (C++20)	非アトミックオブジェクトに対するアトミック操作を提供します (クラステンプレート)
atomic_flag (C++11)	ロックフリーなアトミックブーリアン型 (クラス)
memory_order (C++11)	指定されたアトミック操作のメモリ順序制約を定義します (列挙)
typedef
std::atomic_bool	std::atomic<bool>
std::atomic_char	std::atomic<char>
std::atomic_schar	std::atomic<signed char>
std::atomic_uchar	std::atomic<unsigned char>
std::atomic_short	std::atomic<short>
std::atomic_ushort	std::atomic<unsigned short>
std::atomic_int	std::atomic<int>
std::atomic_uint	std::atomic<unsigned int>
std::atomic_long	std::atomic<long>
std::atomic_ulong	std::atomic<unsigned long>
std::atomic_llong	std::atomic<long long>
std::atomic_ullong	std::atomic<unsigned long long>
std::atomic_char16_t	std::atomic<char16_t>
std::atomic_char32_t	std::atomic<char32_t>
std::atomic_wchar_t	std::atomic<wchar_t>
std::atomic_int8_t	std::atomic<std::int8_t>
std::atomic_uint8_t	std::atomic<std::uint8_t>
std::atomic_int16_t	std::atomic<std::int16_t>
std::atomic_uint16_t	std::atomic<std::uint16_t>
std::atomic_int32_t	std::atomic<std::int32_t>
std::atomic_uint32_t	std::atomic<std::uint32_t>
std::atomic_int64_t	std::atomic<std::int64_t>
std::atomic_uint64_t	std::atomic<std::uint64_t>
std::atomic_int_least8_t	std::atomic<int_least8_t>
std::atomic_uint_least8_t	std::atomic<uint_least8_t>
std::atomic_int_least16_t	std::atomic<int_least16_t>
std::atomic_uint_least16_t	std::atomic<uint_least16_t>
std::atomic_int_least32_t	std::atomic<int_least32_t>
std::atomic_uint_least32_t	std::atomic<uint_least32_t>
std::atomic_int_least64_t	std::atomic<int_least64_t>
std::atomic_uint_least64_t	std::atomic<uint_least64_t>
std::atomic_int_fast8_t	std::atomic<int_fast8_t>
std::atomic_uint_fast8_t	std::atomic<uint_fast8_t>
std::atomic_int_fast16_t	std::atomic<int_fast16_t>
std::atomic_uint_fast16_t	std::atomic<uint_fast16_t>
std::atomic_int_fast32_t	std::atomic<int_fast32_t>
std::atomic_uint_fast32_t	std::atomic<uint_fast32_t>
std::atomic_int_fast64_t	std::atomic<int_fast64_t>
std::atomic_uint_fast64_t	std::atomic<uint_fast64_t>
std::atomic_intptr_t	std::atomic<intptr_t>
std::atomic_uintptr_t	std::atomic<uintptr_t>
std::atomic_size_t	std::atomic<size_t>
std::atomic_ptrdiff_t	std::atomic<ptrdiff_t>
std::atomic_intmax_t	std::atomic<intmax_t>
std::atomic_uintmax_t	std::atomic<uintmax_t>
関数
atomic_is_lock_free (C++11)	アトミック型の操作がロックフリーかどうか調べます (関数テンプレート)
atomic_storeatomic_store_explicit (C++11)(C++11)	アトミックオブジェクトの値を非アトミック引数でアトミックに置き換えます (関数テンプレート)
atomic_loadatomic_load_explicit (C++11)(C++11)	アトミックオブジェクトに格納されている値をアトミックに取得します (関数テンプレート)
atomic_exchangeatomic_exchange_explicit (C++11)(C++11)	アトミックオブジェクトの値を非アトミック引数でアトミックに置き換え、そのアトミックの古い値を返します (関数テンプレート)
atomic_compare_exchange_weakatomic_compare_exchange_weak_explicitatomic_compare_exchange_strongatomic_compare_exchange_strong_explicit (C++11)(C++11)(C++11)(C++11)	アトミックに、アトミックオブジェクトの値を非アトミック引数と比較し、等しければ交換を行い、等しくなければ読み込みます (関数テンプレート)
atomic_fetch_addatomic_fetch_add_explicit (C++11)(C++11)	アトミックオブジェクトに非アトミック値を加算し、そのアトミックの以前の値を取得します (関数テンプレート)
atomic_fetch_subatomic_fetch_sub_explicit (C++11)(C++11)	アトミックオブジェクトから非アトミック値を減算し、アトミックの以前の値を取得します (関数テンプレート)
atomic_fetch_andatomic_fetch_and_explicit (C++11)(C++11)	アトミックオブジェクトの値を非アトミック引数とビット単位の論理積を取った結果で置き換え、アトミックの以前の値を取得します (関数テンプレート)
atomic_fetch_oratomic_fetch_or_explicit (C++11)(C++11)	アトミックオブジェクトの値を非アトミック引数とビット単位の論理和を取った結果で置き換え、アトミックの以前の値を取得します (関数テンプレート)
atomic_fetch_xoratomic_fetch_xor_explicit (C++11)(C++11)	アトミックオブジェクトの値を非アトミック引数とビット単位の排他的論理和を取った結果で置き換え、アトミックの以前の値を取得します (関数テンプレート)
atomic_flag_test_and_setatomic_flag_test_and_set_explicit (C++11)(C++11)	アトミックにフラグを true に設定し、その以前の値を返します (関数)
atomic_flag_clearatomic_flag_clear_explicit (C++11)(C++11)	アトミックにフラグの値を false に設定します (関数)
atomic_init (C++11)	デフォルト構築されたアトミックオブジェクトの非アトミックな初期化を行います (関数テンプレート)
kill_dependency (C++11)	std::memory_order_consume の依存関係ツリーから指定されたオブジェクトを削除します (関数テンプレート)
atomic_thread_fence (C++11)	汎用のメモリ順序依存関係のフェンス同期プリミティブ (関数)
atomic_signal_fence (C++11)	同じスレッドで実行されるシグナルハンドラとの間のフェンス (関数)
プリプロセッサマクロ
ATOMIC_VAR_INIT (C++11)	静的記憶域期間のアトミック変数の定数初期化 (関数マクロ)
ATOMIC_FLAG_INIT (C++11)	std::atomic_flag を false に初期化します (マクロ定数)

概要

namespace std {
 
    /* before C++17:
 
    typedef enum memory_order {
        memory_order_relaxed,
        memory_order_consume,
        memory_order_acquire,
        memory_order_release,
        memory_order_acq_rel,
        memory_order_seq_cst
    } memory_order;
 
    */
 
    enum class memory_order : /*unspecified*/ {
        relaxed, consume, acquire, release, acq_rel, seq_cst
    };
 
    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;
 
    // lock-free property
    #define ATOMIC_BOOL_LOCK_FREE /*unspecified*/
    #define ATOMIC_CHAR_LOCK_FREE /*unspecified*/
    #define ATOMIC_CHAR16_T_LOCK_FREE /*unspecified*/
    #define ATOMIC_CHAR32_T_LOCK_FREE /*unspecified*/
    #define ATOMIC_WCHAR_T_LOCK_FREE /*unspecified*/
    #define ATOMIC_SHORT_LOCK_FREE /*unspecified*/
    #define ATOMIC_INT_LOCK_FREE /*unspecified*/
    #define ATOMIC_LONG_LOCK_FREE /*unspecified*/
    #define ATOMIC_LLONG_LOCK_FREE /*unspecified*/
    #define ATOMIC_POINTER_LOCK_FREE /*unspecified*/
 
    // class template atomic_ref
    template<class T> struct atomic_ref;
    // partial specialization for pointers
    template<class T> struct atomic_ref<T*>;
 
    // generic atomic type
    template<class T> struct atomic;
    // specialization for pointers
    template<class T> struct atomic<T*>;
 
    // named typedefs
    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_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>;
 
    // non-member functions
    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_init(volatile atomic<T>*, typename atomic<T>::value_type) noexcept;
    template<class T>
    void atomic_init(atomic<T>*, typename atomic<T>::value_type) 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;
 
    // initialization
    #define ATOMIC_VAR_INIT(value) /*see description*/
 
    // flag type and operations
    struct atomic_flag;
 
    bool atomic_flag_test_and_set(volatile atomic_flag*) noexcept;
    bool atomic_flag_test_and_set(atomic_flag*) noexcept;
    bool atomic_flag_test_and_set_explicit(volatile atomic_flag*,
                                           memory_order) noexcept;
    bool atomic_flag_test_and_set_explicit(atomic_flag*, memory_order) noexcept;
    void atomic_flag_clear(volatile atomic_flag*) noexcept;
    void atomic_flag_clear(atomic_flag*) noexcept;
    void atomic_flag_clear_explicit(volatile atomic_flag*, memory_order) noexcept;
    void atomic_flag_clear_explicit(atomic_flag*, memory_order) noexcept;
 
    #define ATOMIC_FLAG_INIT /*see description*/
 
    // fences
    extern "C" void atomic_thread_fence(memory_order) noexcept;
    extern "C" void atomic_signal_fence(memory_order) noexcept;

クラス std::atomic

template <class T> struct atomic {
    using value_type = T;
 
    bool is_lock_free() const volatile noexcept;
    bool is_lock_free() const noexcept;
    void store(T, memory_order = memory_order_seq_cst) volatile noexcept;
    void store(T, memory_order = memory_order_seq_cst) noexcept;
    T load(memory_order = memory_order_seq_cst) const volatile noexcept;
    T load(memory_order = memory_order_seq_cst) const noexcept;
    operator T() const volatile noexcept;
    operator T() const noexcept;
    T exchange(T, memory_order = memory_order_seq_cst) volatile noexcept;
    T exchange(T, memory_order = memory_order_seq_cst) noexcept;
    bool compare_exchange_weak(T&, T,
                               memory_order, memory_order) volatile noexcept;
    bool compare_exchange_weak(T&, T,
                               memory_order, memory_order) noexcept;
    bool compare_exchange_strong(T&, T,
                                 memory_order, memory_order) volatile noexcept;
    bool compare_exchange_strong(T&, T,
                                 memory_order, memory_order) noexcept;
    bool compare_exchange_weak(T&, T,
                               memory_order = memory_order_seq_cst) volatile noexcept;
    bool compare_exchange_weak(T&, T,
                               memory_order = memory_order_seq_cst) noexcept;
    bool compare_exchange_strong(T&, T,
                                 memory_order = memory_order_seq_cst) volatile noexcept;
    bool compare_exchange_strong(T&, T,
                                 memory_order = memory_order_seq_cst) noexcept;
 
    atomic() noexcept = default;
    constexpr atomic(T) noexcept;
    atomic(const atomic&) = delete;
    atomic& operator=(const atomic&) = delete;
    atomic& operator=(const atomic&) volatile = delete;
    T operator=(T) volatile noexcept;
    T operator=(T) noexcept;
};

整数型に対する std::atomic の特殊化

template<> struct atomic</*integral*/> {
    using value_type = /*integral*/;
    using difference_type = value_type;
 
    bool is_lock_free() const volatile noexcept;
    bool is_lock_free() const noexcept;
    void store(/*integral*/,
               memory_order = memory_order_seq_cst) volatile noexcept;
    void store(/*integral*/,
               memory_order = memory_order_seq_cst) noexcept;
    /*integral*/ load(memory_order = memory_order_seq_cst) const volatile noexcept;
    /*integral*/ load(memory_order = memory_order_seq_cst) const noexcept;
    operator /*integral*/() const volatile noexcept;
    operator /*integral*/() const noexcept;
    /*integral*/ exchange(/*integral*/,
                          memory_order = memory_order_seq_cst) volatile noexcept;
    /*integral*/ exchange(/*integral*/,
                          memory_order = memory_order_seq_cst) noexcept;
    bool compare_exchange_weak(/*integral*/&, /*integral*/,
                               memory_order, memory_order) volatile noexcept;
    bool compare_exchange_weak(/*integral*/&, /*integral*/,
                               memory_order, memory_order) noexcept;
    bool compare_exchange_strong(/*integral*/&, /*integral*/,
                                 memory_order, memory_order) volatile noexcept;
    bool compare_exchange_strong(/*integral*/&, /*integral*/,
                                 memory_order, memory_order) noexcept;
    bool compare_exchange_weak(/*integral*/&, /*integral*/,
                               memory_order = memory_order_seq_cst) volatile noexcept;
    bool compare_exchange_weak(/*integral*/&, /*integral*/,
                               memory_order = memory_order_seq_cst) noexcept;
    bool compare_exchange_strong(/*integral*/&, /*integral*/,
                                 memory_order = memory_order_seq_cst) volatile noexcept;
    bool compare_exchange_strong(/*integral*/&, /*integral*/,
                                 memory_order = memory_order_seq_cst) noexcept;
    /*integral*/ fetch_add(/*integral*/,
                           memory_order = memory_order_seq_cst) volatile noexcept;
    /*integral*/ fetch_add(/*integral*/,
                           memory_order = memory_order_seq_cst) noexcept;
    /*integral*/ fetch_sub(/*integral*/,
                           memory_order = memory_order_seq_cst) volatile noexcept;
    /*integral*/ fetch_sub(/*integral*/,
                           memory_order = memory_order_seq_cst) noexcept;
    /*integral*/ fetch_and(/*integral*/,
                           memory_order = memory_order_seq_cst) volatile noexcept;
    /*integral*/ fetch_and(/*integral*/,
                           memory_order = memory_order_seq_cst) noexcept;
    /*integral*/ fetch_or(/*integral*/,
                          memory_order = memory_order_seq_cst) volatile noexcept;
    /*integral*/ fetch_or(/*integral*/,
                          memory_order = memory_order_seq_cst) noexcept;
    /*integral*/ fetch_xor(/*integral*/,
                           memory_order = memory_order_seq_cst) volatile noexcept;
    /*integral*/ fetch_xor(/*integral*/,
                           memory_order = memory_order_seq_cst) noexcept;
 
    atomic() noexcept = default;
    constexpr atomic(/*integral*/) noexcept;
    atomic(const atomic&) = delete;
    atomic& operator=(const atomic&) = delete;
    atomic& operator=(const atomic&) volatile = delete;
    /*integral*/ operator=(/*integral*/) volatile noexcept;
    /*integral*/ operator=(/*integral*/) noexcept;
    /*integral*/ operator++(int) volatile noexcept;
    /*integral*/ operator++(int) noexcept;
    /*integral*/ operator--(int) volatile noexcept;
    /*integral*/ operator--(int) noexcept;
    /*integral*/ operator++() volatile noexcept;
    /*integral*/ operator++() noexcept;
    /*integral*/ operator--() volatile noexcept;
    /*integral*/ operator--() noexcept;
    /*integral*/ operator+=(/*integral*/) volatile noexcept;
    /*integral*/ operator+=(/*integral*/) noexcept;
    /*integral*/ operator-=(/*integral*/) volatile noexcept;
    /*integral*/ operator-=(/*integral*/) noexcept;
    /*integral*/ operator&=(/*integral*/) volatile noexcept;
    /*integral*/ operator&=(/*integral*/) noexcept;
    /*integral*/ operator|=(/*integral*/) volatile noexcept;
    /*integral*/ operator|=(/*integral*/) noexcept;
    /*integral*/ operator^=(/*integral*/) volatile noexcept;
    /*integral*/ operator^=(/*integral*/) noexcept;
};

浮動小数点型に対する std::atomic の特殊化

template<> struct atomic</*floating-point*/> {
    using value_type = /*floating-point*/;
    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;
    void store(/*floating-point*/, memory_order = memory_order_seq_cst) volatile noexcept;
    void store(/*floating-point*/, memory_order = memory_order_seq_cst) noexcept;
    /*floating-point*/ load(memory_order = memory_order_seq_cst) volatile noexcept;
    /*floating-point*/ load(memory_order = memory_order_seq_cst) noexcept;
    operator /*floating-point*/() volatile noexcept;
    operator /*floating-point*/() noexcept;
    /*floating-point*/ exchange(/*floating-point*/,
                                memory_order = memory_order_seq_cst) volatile noexcept;
    /*floating-point*/ exchange(/*floating-point*/,
                                memory_order = memory_order_seq_cst) noexcept;
    bool compare_exchange_weak(/*floating-point*/&, /*floating-point*/,
                                memory_order, memory_order) volatile noexcept;
    bool compare_exchange_weak(/*floating-point*/&, /*floating-point*/,
                               memory_order, memory_order) noexcept;
    bool compare_exchange_strong(/*floating-point*/&, /*floating-point*/,
                                 memory_order, memory_order) volatile noexcept;
    bool compare_exchange_strong(/*floating-point*/&, /*floating-point*/,
                                 memory_order, memory_order) noexcept;
    bool compare_exchange_weak(/*floating-point*/&, /*floating-point*/,
                               memory_order = memory_order_seq_cst) volatile noexcept;
    bool compare_exchange_weak(/*floating-point*/&, /*floating-point*/,
                               memory_order = memory_order_seq_cst) noexcept;
    bool compare_exchange_strong(/*floating-point*/&, /*floating-point*/,
                                 memory_order = memory_order_seq_cst) volatile noexcept;
    bool compare_exchange_strong(/*floating-point*/&, /*floating-point*/,
                                 memory_order = memory_order_seq_cst) noexcept;
 
    /*floating-point*/ fetch_add(/*floating-point*/,
                                 memory_order = memory_order_seq_cst) volatile noexcept;
    /*floating-point*/ fetch_add(/*floating-point*/,
                                 memory_order = memory_order_seq_cst) noexcept;
    /*floating-point*/ fetch_sub(/*floating-point*/,
                                 memory_order = memory_order_seq_cst) volatile noexcept;
    /*floating-point*/ fetch_sub(/*floating-point*/,
                                 memory_order = memory_order_seq_cst) noexcept;
 
    atomic() noexcept = default;
    constexpr atomic(/*floating-point*/) noexcept;
 
    atomic(const atomic&) = delete;
    atomic& operator=(const atomic&) = delete;
    atomic& operator=(const atomic&) volatile = delete;
    /*floating-point*/ operator=(/*floating-point*/) volatile noexcept;
    /*floating-point*/ operator=(/*floating-point*/) noexcept;
 
    /*floating-point*/ operator+=(/*floating-point*/) volatile noexcept;
    /*floating-point*/ operator+=(/*floating-point*/) noexcept;
    /*floating-point*/ operator-=(/*floating-point*/) volatile noexcept;
    /*floating-point*/ operator-=(/*floating-point*/) noexcept;
};

ポインタ型に対する std::atomic の特殊化

template <class T> struct atomic<T*> {
    using value_type = T*;
    using difference_type = ptrdiff_t;
 
    bool is_lock_free() const volatile noexcept;
    bool is_lock_free() const noexcept;
    void store(T*, memory_order = memory_order_seq_cst) volatile noexcept;
    void store(T*, memory_order = memory_order_seq_cst) noexcept;
    T* load(memory_order = memory_order_seq_cst) const volatile noexcept;
    T* load(memory_order = memory_order_seq_cst) const noexcept;
    operator T*() const volatile noexcept;
    operator T*() const noexcept;
    T* exchange(T*, memory_order = memory_order_seq_cst) volatile noexcept;
    T* exchange(T*, memory_order = memory_order_seq_cst) noexcept;
    bool compare_exchange_weak(T*&, T*, memory_order, memory_order) volatile noexcept;
    bool compare_exchange_weak(T*&, T*, memory_order, memory_order) noexcept;
    bool compare_exchange_strong(T*&, T*, memory_order, memory_order) volatile noexcept;
    bool compare_exchange_strong(T*&, T*, memory_order, memory_order) noexcept;
    bool compare_exchange_weak(T*&, T*,
                               memory_order = memory_order_seq_cst) volatile noexcept;
    bool compare_exchange_weak(T*&, T*,
                               memory_order = memory_order_seq_cst) noexcept;
    bool compare_exchange_strong(T*&, T*,
                                 memory_order = memory_order_seq_cst) volatile noexcept;
    bool compare_exchange_strong(T*&, T*,
                                 memory_order = memory_order_seq_cst) noexcept;
    T* fetch_add(ptrdiff_t, memory_order = memory_order_seq_cst) volatile noexcept;
    T* fetch_add(ptrdiff_t, memory_order = memory_order_seq_cst) noexcept;
    T* fetch_sub(ptrdiff_t, memory_order = memory_order_seq_cst) volatile noexcept;
    T* fetch_sub(ptrdiff_t, memory_order = memory_order_seq_cst) noexcept;
 
    atomic() noexcept = default;
    constexpr atomic(T*) noexcept;
    atomic(const atomic&) = delete;
    atomic& operator=(const atomic&) = delete;
    atomic& operator=(const atomic&) volatile = delete;
    T* operator=(T*) volatile noexcept;
    T* operator=(T*) noexcept;
    T* operator++(int) volatile noexcept;
    T* operator++(int) noexcept;
    T* operator--(int) volatile noexcept;
    T* operator--(int) noexcept;
    T* operator++() volatile noexcept;
    T* operator++() noexcept;
    T* operator--() volatile noexcept;
    T* operator--() noexcept;
    T* operator+=(ptrdiff_t) volatile noexcept;
    T* operator+=(ptrdiff_t) noexcept;
    T* operator-=(ptrdiff_t) volatile noexcept;
    T* operator-=(ptrdiff_t) noexcept;
};

クラス std::atomic_ref

template<class T> struct atomic_ref {
private:
    T* ptr; // exposition only
public:
    using value_type = T;
    static constexpr bool is_always_lock_free = /*implementation-defined*/;
    static constexpr size_t required_alignment = /*implementation-defined*/;
 
    atomic_ref() = delete;
    atomic_ref& operator=(const atomic_ref&) = delete;
 
    explicit atomic_ref(T&);
    atomic_ref(const atomic_ref&) noexcept;
 
    T operator=(T) const noexcept;
    operator T() const noexcept;
 
    bool is_lock_free() const noexcept;
    void store(T, memory_order = memory_order_seq_cst) const noexcept;
    T load(memory_order = memory_order_seq_cst) 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;
};

整数型に対する std::atomic_ref の特殊化

template<> struct atomic_ref</*integral*/> {
private:
    /*integral*/* ptr; // exposition only
public:
    using value_type = /*integral*/;
    using difference_type = value_type;
    static constexpr bool is_always_lock_free = /*implementation-defined*/;
    static constexpr size_t required_alignment = /*implementation-defined*/;
 
    atomic_ref() = delete;
    atomic_ref& operator=(const atomic_ref&) = delete;
 
    explicit atomic_ref(/*integral*/&);
    atomic_ref(const atomic_ref&) noexcept;
 
    /*integral*/ operator=(/*integral*/) const noexcept;
    operator /*integral*/() const noexcept;
 
    bool is_lock_free() const noexcept;
    void store(/*integral*/, memory_order = memory_order_seq_cst) const noexcept;
    /*integral*/ load(memory_order = memory_order_seq_cst) 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*/ 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 の特殊化

template<> struct atomic_ref</*floating-point*/> {
private:
    /*floating-point*/* ptr; // exposition only
public:
    using value_type = /*floating-point*/;
    using difference_type = value_type;
    static constexpr bool is_always_lock_free = /*implementation-defined*/;
    static constexpr size_t required_alignment = /*implementation-defined*/;
 
    atomic_ref() = delete;
    atomic_ref& operator=(const atomic_ref&) = delete;
 
    explicit atomic_ref(/*floating-point*/&);
    atomic_ref(const atomic_ref&) noexcept;
 
    /*floating-point*/ operator=(/*floating-point*/) noexcept;
    operator /*floating-point*/() const noexcept;
 
    bool is_lock_free() const noexcept;
    void store(/*floating-point*/, memory_order = memory_order_seq_cst) const noexcept;
    /*floating-point*/ load(memory_order = memory_order_seq_cst) 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;
};

ポインタ型に対する std::atomic_ref の特殊化

template<class T> struct atomic_ref<T*> {
private:
    T** ptr; // exposition only
public:
    using value_type = T*;
    using difference_type = ptrdiff_t;
    static constexpr bool is_always_lock_free = /*implementation-defined*/;
    static constexpr size_t required_alignment = /*implementation-defined*/;
 
    atomic_ref() = delete;
    atomic_ref& operator=(const atomic_ref&) = delete;
 
    explicit atomic_ref(T*&);
    atomic_ref(const atomic_ref&) noexcept;
 
    T* operator=(T*) const noexcept;
    operator T*() const noexcept;
 
    bool is_lock_free() const noexcept;
    void store(T*, memory_order = memory_order_seq_cst) const noexcept;
    T* load(memory_order = memory_order_seq_cst) 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* 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;
};

クラス std::atomic_flag

typedef struct atomic_flag {
    bool test_and_set(memory_order = memory_order_seq_cst) volatile noexcept;
    bool test_and_set(memory_order = memory_order_seq_cst) noexcept;
    void clear(memory_order = memory_order_seq_cst) volatile noexcept;
    void clear(memory_order = memory_order_seq_cst) noexcept;
    atomic_flag() noexcept = default;
    atomic_flag(const atomic_flag&) = delete;
    atomic_flag& operator=(const atomic_flag&) = delete;
    atomic_flag& operator=(const atomic_flag&) volatile = delete;
} atomic_flag;