atomic_8hpp_source.html

#ifndef NEFORCE_CORE_ASYNC_ATOMIC_HPP__

#define NEFORCE_CORE_ASYNC_ATOMIC_HPP__


#include "NeForce/core/async/atomic_base.hpp"

NEFORCE_BEGIN_NAMESPACE__


template <typename T>

struct atomic;


template <typename T>


struct atomic {

    using value_type = T;


private:

    static constexpr int min_align = (sizeof(T) & (sizeof(T) - 1)) || sizeof(T) > 16 ? 0 : sizeof(T);

    static constexpr int align_inner = min_align > alignof(T) ? min_align : alignof(T);


    alignas(align_inner) T value_;


    static_assert(is_trivially_copyable_v<T>, "atomic requires a trivially copyable type");

    static_assert(sizeof(T) > 0, "Incomplete or zero-sized types are not supported");

    static_assert(is_copy_constructible_v<T>, "atomic need copy constructible T");

    static_assert(is_move_constructible_v<T>, "atomic need move constructible T");

    static_assert(is_copy_assignable_v<T>, "atomic copy move assignable T");

    static_assert(is_move_assignable_v<T>, "atomic need move assignable T");


public:

    atomic() = default;

    ~atomic() noexcept = default;

    atomic(const atomic&) = delete;

    atomic& operator=(const atomic&) = delete;

    atomic& operator=(const atomic&) volatile = delete;

    atomic(atomic&&) noexcept = default;

    atomic& operator=(atomic&&) noexcept = default;


    constexpr atomic(T value) noexcept :

    value_(value) {}


    operator T() const noexcept { return load(); }


    operator T() const volatile noexcept { return load(); }


    T operator=(T value) noexcept {

        atomic::store(value);

        return value;

    }


    T operator=(T value) volatile noexcept {

        atomic::store(value);

        return value;

    }


    bool is_lock_free() const noexcept { return _NEFORCE is_always_lock_free<sizeof(value_), align_inner>(); }


    bool is_lock_free() const volatile noexcept { return _NEFORCE is_always_lock_free<sizeof(value_), align_inner>(); }


    void store(T value, const memory_order mo = memory_order_seq_cst) noexcept {

        _NEFORCE atomic_store_any(_NEFORCE addressof(value_), value, mo);

    }


    void store(T value, const memory_order mo = memory_order_seq_cst) volatile noexcept {

        _NEFORCE atomic_store_any(_NEFORCE addressof(value_), value, mo);

    }


    T load(const memory_order mo = memory_order_seq_cst) const noexcept {

        return _NEFORCE atomic_load_any(_NEFORCE addressof(value_), mo);

    }


    T load(const memory_order mo = memory_order_seq_cst) const volatile noexcept {

        return _NEFORCE atomic_load_any(_NEFORCE addressof(value_), mo);

    }


    T exchange(T value, const memory_order mo = memory_order_seq_cst) noexcept {

        return _NEFORCE atomic_exchange_any(_NEFORCE addressof(value_), value, mo);

    }


    T exchange(T value, const memory_order mo = memory_order_seq_cst) volatile noexcept {

        return _NEFORCE atomic_exchange_any(_NEFORCE addressof(value_), value, mo);

    }


    bool compare_exchange_weak(T& expected, T desired, const memory_order success,

                               const memory_order failure) noexcept {

        NEFORCE_CONSTEXPR_ASSERT(is_valid_cmpexch_failure_order(failure));

        return _NEFORCE atomic_cmpexch_weak_any(_NEFORCE addressof(value_), &expected, &desired, success, failure);

    }


    bool compare_exchange_weak(T& expected, T desired, const memory_order success,

                               const memory_order failure) volatile noexcept {

        NEFORCE_CONSTEXPR_ASSERT(is_valid_cmpexch_failure_order(failure));

        return _NEFORCE atomic_cmpexch_weak_any(_NEFORCE addressof(value_), &expected, &desired, success, failure);

    }


    bool compare_exchange_weak(T& expected, T desired, const memory_order mo = memory_order_seq_cst) noexcept {

        return atomic::compare_exchange_weak(expected, desired, mo, cmpexch_failure_order(mo));

    }


    bool compare_exchange_weak(T& expected, T desired, const memory_order mo = memory_order_seq_cst) volatile noexcept {

        return atomic::compare_exchange_weak(expected, desired, mo, cmpexch_failure_order(mo));

    }


    bool compare_exchange_strong(T& expected, T desired, const memory_order success,

                                 const memory_order failure) noexcept {

        NEFORCE_CONSTEXPR_ASSERT(is_valid_cmpexch_failure_order(failure));

        return _NEFORCE atomic_cmpexch_strong_any(_NEFORCE addressof(value_), _NEFORCE addressof(expected),

                                                  _NEFORCE addressof(desired), success, failure);

    }


    bool compare_exchange_strong(T& expected, T desired, const memory_order success,

                                 const memory_order failure) volatile noexcept {

        NEFORCE_CONSTEXPR_ASSERT(is_valid_cmpexch_failure_order(failure));

        return _NEFORCE atomic_cmpexch_strong_any(_NEFORCE addressof(value_), _NEFORCE addressof(expected),

                                                  _NEFORCE addressof(desired), success, failure);

    }


    bool compare_exchange_strong(T& expected, T value, const memory_order mo = memory_order_seq_cst) noexcept {

        return atomic::compare_exchange_strong(expected, value, mo, cmpexch_failure_order(mo));

    }


    bool compare_exchange_strong(T& expected, T value, const memory_order mo = memory_order_seq_cst) volatile noexcept {

        return atomic::compare_exchange_strong(expected, value, mo, cmpexch_failure_order(mo));

    }


};


template <typename T>


struct atomic<T*> : atomic_base<T*> {

    atomic() = default;

    ~atomic() noexcept = default;

    atomic(const atomic&) = delete;

    atomic& operator=(const atomic&) = delete;

    atomic& operator=(const atomic&) volatile = delete;

    atomic(atomic&&) noexcept = default;

    atomic& operator=(atomic&&) noexcept = default;


    explicit atomic(T* value) noexcept :

    atomic_base<T*>(value) {}


    using atomic_base<T*>::operator=;

};


template <typename T>


struct atomic<T&> : atomic_ref_base<T> {

    atomic() = default;

    ~atomic() noexcept = default;

    atomic(const atomic&) = delete;

    atomic& operator=(const atomic&) = delete;

    atomic& operator=(const atomic&) volatile = delete;

    atomic(atomic&&) noexcept = default;

    atomic& operator=(atomic&&) noexcept = default;


    explicit atomic(T& value) noexcept :

    atomic_ref_base<T>(value) {}


    using atomic_ref_base<T>::operator=;

};


template <>


struct atomic<bool> {

    using value_type = bool;


private:

    atomic_base<bool> base_;


public:

    atomic() = default;

    ~atomic() noexcept = default;

    atomic(const atomic&) = delete;

    atomic& operator=(const atomic&) = delete;

    atomic& operator=(const atomic&) volatile = delete;

    atomic(atomic&&) noexcept = default;

    atomic& operator=(atomic&&) noexcept = default;


    constexpr atomic(const bool value) noexcept :

    base_(value) {}


    bool operator=(const bool value) noexcept { return base_.operator=(value); }


    bool operator=(const bool value) volatile noexcept { return base_.operator=(value); }


    operator bool() const noexcept { return base_.load(); }


    operator bool() const volatile noexcept { return base_.load(); }


    bool is_lock_free() const noexcept { return base_.is_lock_free(); }


    bool is_lock_free() const volatile noexcept { return base_.is_lock_free(); }


    void store(const bool value, const memory_order mo = memory_order_seq_cst) noexcept { base_.store(value, mo); }


    void store(const bool value, const memory_order mo = memory_order_seq_cst) volatile noexcept {

        base_.store(value, mo);

    }


    bool load(const memory_order mo = memory_order_seq_cst) const noexcept { return base_.load(mo); }


    bool load(const memory_order mo = memory_order_seq_cst) const volatile noexcept { return base_.load(mo); }


    bool exchange(const bool value, const memory_order mo = memory_order_seq_cst) noexcept {

        return base_.exchange(value, mo);

    }


    bool exchange(const bool value, const memory_order mo = memory_order_seq_cst) volatile noexcept {

        return base_.exchange(value, mo);

    }


    bool compare_exchange_weak(bool& value1, const bool value2, const memory_order success,

                               const memory_order failure) noexcept {

        return base_.compare_exchange_weak(value1, value2, success, failure);

    }


    bool compare_exchange_weak(bool& value1, const bool value2, const memory_order success,

                               const memory_order failure) volatile noexcept {

        return base_.compare_exchange_weak(value1, value2, success, failure);

    }


    bool compare_exchange_weak(bool& value1, const bool value2, const memory_order mo = memory_order_seq_cst) noexcept {

        return base_.compare_exchange_weak(value1, value2, mo);

    }


    bool compare_exchange_weak(bool& value1, const bool value2,

                               const memory_order mo = memory_order_seq_cst) volatile noexcept {

        return base_.compare_exchange_weak(value1, value2, mo);

    }


    bool compare_exchange_strong(bool& value1, const bool value2, const memory_order success,

                                 const memory_order failure) noexcept {

        return base_.compare_exchange_strong(value1, value2, success, failure);

    }


    bool compare_exchange_strong(bool& value1, const bool value2, const memory_order success,

                                 const memory_order failure) volatile noexcept {

        return base_.compare_exchange_strong(value1, value2, success, failure);

    }


    bool compare_exchange_strong(bool& value1, const bool value2,

                                 const memory_order mo = memory_order_seq_cst) noexcept {

        return base_.compare_exchange_strong(value1, value2, mo);

    }


    bool compare_exchange_strong(bool& value1, const bool value2,

                                 const memory_order mo = memory_order_seq_cst) volatile noexcept {

        return base_.compare_exchange_strong(value1, value2, mo);

    }


    void wait(const bool old, const memory_order mo = memory_order_seq_cst) const noexcept { base_.wait(old, mo); }


    void notify_one() noexcept { base_.notify_one(); }


    void notify_all() noexcept { base_.notify_all(); }

};


template <>


struct atomic<char> : atomic_base<char> {

    using integral_type = char;

    using base_type = atomic_base<char>;


    atomic() = default;

    ~atomic() noexcept = default;

    atomic(const atomic&) = delete;

    atomic& operator=(const atomic&) = delete;

    atomic& operator=(const atomic&) volatile = delete;

    atomic(atomic&&) noexcept = default;

    atomic& operator=(atomic&&) noexcept = default;


    constexpr atomic(const integral_type value) noexcept :

    base_type(value) {}


    using base_type::operator integral_type;

    using base_type::operator=;


    static constexpr bool is_always_lock_free = true;

};


template <>


struct atomic<signed char> : atomic_base<signed char> {

    using integral_type = signed char;

    using base_type = atomic_base<signed char>;


    atomic() = default;

    ~atomic() noexcept = default;

    atomic(const atomic&) = delete;

    atomic& operator=(const atomic&) = delete;

    atomic& operator=(const atomic&) volatile = delete;

    atomic(atomic&&) noexcept = default;

    atomic& operator=(atomic&&) noexcept = default;


    constexpr atomic(const integral_type value) noexcept :

    base_type(value) {}


    using base_type::operator integral_type;

    using base_type::operator=;


    static constexpr bool is_always_lock_free = true;

};


template <>


struct atomic<unsigned char> : atomic_base<unsigned char> {

    using integral_type = unsigned char;

    using base_type = atomic_base<unsigned char>;


    atomic() = default;

    ~atomic() noexcept = default;

    atomic(const atomic&) = delete;

    atomic& operator=(const atomic&) = delete;

    atomic& operator=(const atomic&) volatile = delete;

    atomic(atomic&&) noexcept = default;

    atomic& operator=(atomic&&) noexcept = default;


    constexpr atomic(const integral_type value) noexcept :

    base_type(value) {}


    using base_type::operator integral_type;

    using base_type::operator=;


    static constexpr bool is_always_lock_free = true;

};


template <>


struct atomic<short> : atomic_base<short> {

    using integral_type = short;

    using base_type = atomic_base<short>;


    atomic() = default;

    ~atomic() noexcept = default;

    atomic(const atomic&) = delete;

    atomic& operator=(const atomic&) = delete;

    atomic& operator=(const atomic&) volatile = delete;

    atomic(atomic&&) noexcept = default;

    atomic& operator=(atomic&&) noexcept = default;


    constexpr atomic(const integral_type value) noexcept :

    base_type(value) {}


    using base_type::operator integral_type;

    using base_type::operator=;


    static constexpr bool is_always_lock_free = true;

};


template <>


struct atomic<unsigned short> : atomic_base<unsigned short> {

    using integral_type = unsigned short;

    using base_type = atomic_base<unsigned short>;


    atomic() = default;

    ~atomic() noexcept = default;

    atomic(const atomic&) = delete;

    atomic& operator=(const atomic&) = delete;

    atomic& operator=(const atomic&) volatile = delete;

    atomic(atomic&&) noexcept = default;

    atomic& operator=(atomic&&) noexcept = default;


    constexpr atomic(const integral_type value) noexcept :

    base_type(value) {}


    using base_type::operator integral_type;

    using base_type::operator=;


    static constexpr bool is_always_lock_free = true;

};


template <>


struct atomic<int> : atomic_base<int> {

    using integral_type = int;

    using base_type = atomic_base<int>;


    atomic() = default;

    ~atomic() noexcept = default;

    atomic(const atomic&) = delete;

    atomic& operator=(const atomic&) = delete;

    atomic& operator=(const atomic&) volatile = delete;

    atomic(atomic&&) noexcept = default;

    atomic& operator=(atomic&&) noexcept = default;


    constexpr atomic(const integral_type value) noexcept :

    base_type(value) {}


    using base_type::operator integral_type;

    using base_type::operator=;


    static constexpr bool is_always_lock_free = true;

};


template <>


struct atomic<unsigned int> : atomic_base<unsigned int> {

    using integral_type = unsigned int;

    using base_type = atomic_base<unsigned int>;


    atomic() = default;

    ~atomic() noexcept = default;

    atomic(const atomic&) = delete;

    atomic& operator=(const atomic&) = delete;

    atomic& operator=(const atomic&) volatile = delete;

    atomic(atomic&&) noexcept = default;

    atomic& operator=(atomic&&) noexcept = default;


    constexpr atomic(const integral_type value) noexcept :

    base_type(value) {}


    using base_type::operator integral_type;

    using base_type::operator=;


    static constexpr bool is_always_lock_free = true;

};


template <>


struct atomic<long> : atomic_base<long> {

    using integral_type = long;

    using base_type = atomic_base<long>;


    atomic() = default;

    ~atomic() noexcept = default;

    atomic(const atomic&) = delete;

    atomic& operator=(const atomic&) = delete;

    atomic& operator=(const atomic&) volatile = delete;

    atomic(atomic&&) noexcept = default;

    atomic& operator=(atomic&&) noexcept = default;


    constexpr atomic(const integral_type value) noexcept :

    base_type(value) {}


    using base_type::operator integral_type;

    using base_type::operator=;


    static constexpr bool is_always_lock_free = true;

};


template <>


struct atomic<unsigned long> : atomic_base<unsigned long> {

    using integral_type = unsigned long;

    using base_type = atomic_base<unsigned long>;


    atomic() = default;

    ~atomic() noexcept = default;

    atomic(const atomic&) = delete;

    atomic& operator=(const atomic&) = delete;

    atomic& operator=(const atomic&) volatile = delete;

    atomic(atomic&&) noexcept = default;

    atomic& operator=(atomic&&) noexcept = default;


    constexpr atomic(const integral_type value) noexcept :

    base_type(value) {}


    using base_type::operator integral_type;

    using base_type::operator=;


    static constexpr bool is_always_lock_free = true;

};


template <>


struct atomic<long long> : atomic_base<long long> {

    using integral_type = long long;

    using base_type = atomic_base<long long>;


    atomic() = default;

    ~atomic() noexcept = default;

    atomic(const atomic&) = delete;

    atomic& operator=(const atomic&) = delete;

    atomic& operator=(const atomic&) volatile = delete;

    atomic(atomic&&) noexcept = default;

    atomic& operator=(atomic&&) noexcept = default;


    constexpr atomic(const integral_type value) noexcept :

    base_type(value) {}


    using base_type::operator integral_type;

    using base_type::operator=;


    static constexpr bool is_always_lock_free = true;

};


template <>


struct atomic<unsigned long long> : atomic_base<unsigned long long> {

    using integral_type = unsigned long long;

    using base_type = atomic_base<unsigned long long>;


    atomic() = default;

    ~atomic() noexcept = default;

    atomic(const atomic&) = delete;

    atomic& operator=(const atomic&) = delete;

    atomic& operator=(const atomic&) volatile = delete;

    atomic(atomic&&) noexcept = default;

    atomic& operator=(atomic&&) noexcept = default;


    constexpr atomic(const integral_type value) noexcept :

    base_type(value) {}


    using base_type::operator integral_type;

    using base_type::operator=;


    static constexpr bool is_always_lock_free = true;

};


template <>


struct atomic<wchar_t> : atomic_base<wchar_t> {

    using integral_type = wchar_t;

    using base_type = atomic_base<wchar_t>;


    atomic() = default;

    ~atomic() noexcept = default;

    atomic(const atomic&) = delete;

    atomic& operator=(const atomic&) = delete;

    atomic& operator=(const atomic&) volatile = delete;

    atomic(atomic&&) noexcept = default;

    atomic& operator=(atomic&&) noexcept = default;


    constexpr atomic(const integral_type value) noexcept :

    base_type(value) {}


    using base_type::operator integral_type;

    using base_type::operator=;


    static constexpr bool is_always_lock_free = true;

};


#ifdef NEFORCE_STANDARD_20

template <>


struct atomic<char8_t> : atomic_base<char8_t> {

    using integral_type = char8_t;

    using base_type = atomic_base<char8_t>;


    atomic() = default;

    ~atomic() noexcept = default;

    atomic(const atomic&) = delete;

    atomic& operator=(const atomic&) = delete;

    atomic& operator=(const atomic&) volatile = delete;

    atomic(atomic&&) noexcept = default;

    atomic& operator=(atomic&&) noexcept = default;


    constexpr atomic(const integral_type value) noexcept :

    base_type(value) {}


    using base_type::operator integral_type;

    using base_type::operator=;


    static constexpr bool is_always_lock_free = true;

};


#endif


template <>


struct atomic<char16_t> : atomic_base<char16_t> {

    using integral_type = char16_t;

    using base_type = atomic_base<char16_t>;


    atomic() = default;

    ~atomic() noexcept = default;

    atomic(const atomic&) = delete;

    atomic& operator=(const atomic&) = delete;

    atomic& operator=(const atomic&) volatile = delete;

    atomic(atomic&&) noexcept = default;

    atomic& operator=(atomic&&) noexcept = default;


    constexpr atomic(const integral_type value) noexcept :

    base_type(value) {}


    using base_type::operator integral_type;

    using base_type::operator=;


    static constexpr bool is_always_lock_free = true;

};


template <>


struct atomic<char32_t> : atomic_base<char32_t> {

    using integral_type = char32_t;

    using base_type = atomic_base<char32_t>;


    atomic() = default;

    ~atomic() noexcept = default;

    atomic(const atomic&) = delete;

    atomic& operator=(const atomic&) = delete;

    atomic& operator=(const atomic&) volatile = delete;

    atomic(atomic&&) noexcept = default;

    atomic& operator=(atomic&&) noexcept = default;


    constexpr atomic(const integral_type value) noexcept :

    base_type(value) {}


    using base_type::operator integral_type;

    using base_type::operator=;


    static constexpr bool is_always_lock_free = true;

};


template <>


struct atomic<float> : atomic_float_base<float> {

    atomic() = default;

    ~atomic() noexcept = default;

    atomic(const atomic&) = delete;

    atomic& operator=(const atomic&) = delete;

    atomic& operator=(const atomic&) volatile = delete;

    atomic(atomic&&) noexcept = default;

    atomic& operator=(atomic&&) noexcept = default;


    constexpr atomic(const float value) noexcept :

    atomic_float_base<float>(value) {}


    using atomic_float_base<float>::operator=;

};


template <>


struct atomic<double> : atomic_float_base<double> {

    atomic() = default;

    ~atomic() noexcept = default;

    atomic(const atomic&) = delete;

    atomic& operator=(const atomic&) = delete;

    atomic& operator=(const atomic&) volatile = delete;

    atomic(atomic&&) noexcept = default;

    atomic& operator=(atomic&&) noexcept = default;


    constexpr atomic(const double value) noexcept :

    atomic_float_base<double>(value) {}


    using atomic_float_base<double>::operator=;

};


template <>


struct atomic<long double> : atomic_float_base<long double> {

    atomic() = default;

    ~atomic() noexcept = default;

    atomic(const atomic&) = delete;

    atomic& operator=(const atomic&) = delete;

    atomic& operator=(const atomic&) volatile = delete;

    atomic(atomic&&) noexcept = default;

    atomic& operator=(atomic&&) noexcept = default;


    constexpr atomic(const long double value) noexcept :

    atomic_float_base<long double>(value) {}


    using atomic_float_base<long double>::operator=;

};


 // AtomicOperations

 // AsyncComponents


NEFORCE_END_NAMESPACE__

#endif // NEFORCE_CORE_ASYNC_ATOMIC_HPP__

atomic_base.hpp
原子操作基本工具

addressof
NEFORCE_NODISCARD constexpr T * addressof(T &x) noexcept
获取对象的地址
定义 type_traits.hpp:3063

atomic_store_any
NEFORCE_ALWAYS_INLINE_INLINE void atomic_store_any(T *ptr, remove_volatile_t< T > value, const memory_order mo) noexcept
通用原子存储操作
定义 atomic_base.hpp:1015

is_always_lock_free
NEFORCE_CONSTEXPR17 bool is_always_lock_free() noexcept
检查是否支持无锁操作
定义 atomic_base.hpp:1157

atomic_load_any
NEFORCE_ALWAYS_INLINE_INLINE remove_volatile_t< T > atomic_load_any(const T *ptr, memory_order mo) noexcept
通用原子加载操作
定义 atomic_base.hpp:1035

atomic_cmpexch_weak_any
NEFORCE_ALWAYS_INLINE_INLINE bool atomic_cmpexch_weak_any(volatile T *ptr, remove_volatile_t< T > *expected, remove_volatile_t< T > *desired, const memory_order success, const memory_order failure) noexcept
通用弱比较交换操作
定义 atomic_base.hpp:857

atomic_exchange_any
NEFORCE_ALWAYS_INLINE_INLINE remove_volatile_t< T > atomic_exchange_any(T *ptr, remove_volatile_t< T > desired, memory_order mo) noexcept
通用原子交换操作
定义 atomic_base.hpp:1061

atomic_cmpexch_strong_any
NEFORCE_ALWAYS_INLINE_INLINE bool atomic_cmpexch_strong_any(volatile T *ptr, remove_volatile_t< T > *expected, remove_volatile_t< T > *desired, const memory_order success, const memory_order failure) noexcept
通用强比较交换操作
定义 atomic_base.hpp:978

cv_status::success
@ success
等待成功
定义 condition_variable.hpp:34

NEFORCE_CONSTEXPR_ASSERT
#define NEFORCE_CONSTEXPR_ASSERT(COND)
编译时常量断言
定义 breakpoint.hpp:47

is_valid_cmpexch_failure_order
constexpr bool is_valid_cmpexch_failure_order(const memory_order mo) noexcept
检查比较交换失败内存顺序是否有效
定义 memory_order.hpp:220

memory_order_seq_cst
NEFORCE_INLINE17 constexpr auto memory_order_seq_cst
顺序一致性内存顺序常量
定义 memory_order.hpp:149

memory_order
memory_order
内存顺序
定义 memory_order.hpp:129

cmpexch_failure_order
constexpr memory_order cmpexch_failure_order(const memory_order mo) noexcept
获取原子比较交换操作失败时的内存顺序
定义 memory_order.hpp:203

is_copy_constructible_v
NEFORCE_INLINE17 constexpr bool is_copy_constructible_v
is_copy_constructible的便捷变量模板
定义 type_traits.hpp:2371

is_move_assignable_v
NEFORCE_INLINE17 constexpr bool is_move_assignable_v
is_move_assignable的便捷变量模板
定义 type_traits.hpp:2501

is_trivially_copyable_v
NEFORCE_INLINE17 constexpr bool is_trivially_copyable_v
is_trivially_copyable的便捷变量模板
定义 type_traits.hpp:2316

is_move_constructible_v
NEFORCE_INLINE17 constexpr bool is_move_constructible_v
is_move_constructible的便捷变量模板
定义 type_traits.hpp:2441

is_copy_assignable_v
NEFORCE_INLINE17 constexpr bool is_copy_assignable_v
is_copy_assignable的便捷变量模板
定义 type_traits.hpp:2481

atomic< bool >::is_lock_free
bool is_lock_free() const noexcept
检查是否支持无锁操作
定义 atomic.hpp:338

atomic< bool >::compare_exchange_strong
bool compare_exchange_strong(bool &value1, const bool value2, const memory_order mo=memory_order_seq_cst) noexcept
简化版强比较交换操作
定义 atomic.hpp:456

atomic< bool >::operator=
bool operator=(const bool value) noexcept
赋值运算符
定义 atomic.hpp:316

atomic< bool >::store
void store(const bool value, const memory_order mo=memory_order_seq_cst) volatile noexcept
volatile版本的原子存储操作
定义 atomic.hpp:355

atomic< bool >::operator=
bool operator=(const bool value) volatile noexcept
volatile版本的赋值运算符
定义 atomic.hpp:321

atomic< bool >::store
void store(const bool value, const memory_order mo=memory_order_seq_cst) noexcept
原子存储操作
定义 atomic.hpp:350

atomic< bool >::compare_exchange_weak
bool compare_exchange_weak(bool &value1, const bool value2, const memory_order success, const memory_order failure) noexcept
弱比较交换操作
定义 atomic.hpp:396

atomic< bool >::load
bool load(const memory_order mo=memory_order_seq_cst) const volatile noexcept
volatile版本的原子加载操作
定义 atomic.hpp:369

atomic< bool >::exchange
bool exchange(const bool value, const memory_order mo=memory_order_seq_cst) noexcept
原子交换操作
定义 atomic.hpp:377

atomic< bool >::compare_exchange_strong
bool compare_exchange_strong(bool &value1, const bool value2, const memory_order mo=memory_order_seq_cst) volatile noexcept
volatile版本的简化版强比较交换操作
定义 atomic.hpp:464

atomic< bool >::compare_exchange_weak
bool compare_exchange_weak(bool &value1, const bool value2, const memory_order mo=memory_order_seq_cst) volatile noexcept
volatile版本的简化版弱比较交换操作
定义 atomic.hpp:423

atomic< bool >::wait
void wait(const bool old, const memory_order mo=memory_order_seq_cst) const noexcept
等待值改变
定义 atomic.hpp:474

atomic< bool >::value_type
bool value_type
值类型
定义 atomic.hpp:290

atomic< bool >::compare_exchange_strong
bool compare_exchange_strong(bool &value1, const bool value2, const memory_order success, const memory_order failure) noexcept
强比较交换操作
定义 atomic.hpp:436

atomic< bool >::notify_one
void notify_one() noexcept
通知一个等待线程
定义 atomic.hpp:479

atomic< bool >::is_lock_free
bool is_lock_free() const volatile noexcept
volatile版本的检查是否支持无锁操作
定义 atomic.hpp:343

atomic< bool >::exchange
bool exchange(const bool value, const memory_order mo=memory_order_seq_cst) volatile noexcept
volatile版本的原子交换操作
定义 atomic.hpp:384

atomic< bool >::compare_exchange_weak
bool compare_exchange_weak(bool &value1, const bool value2, const memory_order mo=memory_order_seq_cst) noexcept
简化版弱比较交换操作
定义 atomic.hpp:416

atomic< bool >::compare_exchange_weak
bool compare_exchange_weak(bool &value1, const bool value2, const memory_order success, const memory_order failure) volatile noexcept
volatile版本的弱比较交换操作
定义 atomic.hpp:404

atomic< bool >::compare_exchange_strong
bool compare_exchange_strong(bool &value1, const bool value2, const memory_order success, const memory_order failure) volatile noexcept
volatile版本的强比较交换操作
定义 atomic.hpp:444

atomic< bool >::notify_all
void notify_all() noexcept
通知所有等待线程
定义 atomic.hpp:484

atomic< bool >::load
bool load(const memory_order mo=memory_order_seq_cst) const noexcept
原子加载操作
定义 atomic.hpp:364

atomic_base
原子类型基础模板类
定义 atomic_base.hpp:1341

atomic_ref_base
原子引用基础模板类
定义 atomic_base.hpp:2492

atomic
通用原子类型模板
定义 atomic.hpp:37

atomic::compare_exchange_strong
bool compare_exchange_strong(T &expected, T value, const memory_order mo=memory_order_seq_cst) noexcept
简化版强比较交换操作
定义 atomic.hpp:231

atomic::load
T load(const memory_order mo=memory_order_seq_cst) const noexcept
原子加载操作
定义 atomic.hpp:130

atomic::is_lock_free
bool is_lock_free() const noexcept
检查是否支持无锁操作
定义 atomic.hpp:102

atomic::compare_exchange_strong
bool compare_exchange_strong(T &expected, T desired, const memory_order success, const memory_order failure) noexcept
强比较交换操作
定义 atomic.hpp:207

atomic::store
void store(T value, const memory_order mo=memory_order_seq_cst) volatile noexcept
volatile版本的原子存储操作
定义 atomic.hpp:121

atomic::operator=
T operator=(T value) noexcept
赋值运算符
定义 atomic.hpp:85

atomic::store
void store(T value, const memory_order mo=memory_order_seq_cst) noexcept
原子存储操作
定义 atomic.hpp:114

atomic::value_type
T value_type
值类型
定义 atomic.hpp:38

atomic::exchange
T exchange(T value, const memory_order mo=memory_order_seq_cst) noexcept
原子交换操作
定义 atomic.hpp:147

atomic::operator=
T operator=(T value) volatile noexcept
volatile版本的赋值运算符
定义 atomic.hpp:93

atomic::compare_exchange_weak
bool compare_exchange_weak(T &expected, T desired, const memory_order mo=memory_order_seq_cst) noexcept
简化版弱比较交换操作
定义 atomic.hpp:188

atomic::compare_exchange_weak
bool compare_exchange_weak(T &expected, T desired, const memory_order success, const memory_order failure) volatile noexcept
volatile版本的弱比较交换操作
定义 atomic.hpp:175

atomic::compare_exchange_weak
bool compare_exchange_weak(T &expected, T desired, const memory_order mo=memory_order_seq_cst) volatile noexcept
volatile版本的简化版弱比较交换操作
定义 atomic.hpp:195

atomic::exchange
T exchange(T value, const memory_order mo=memory_order_seq_cst) volatile noexcept
volatile版本的原子交换操作
定义 atomic.hpp:154

atomic::compare_exchange_strong
bool compare_exchange_strong(T &expected, T desired, const memory_order success, const memory_order failure) volatile noexcept
volatile版本的强比较交换操作
定义 atomic.hpp:217

atomic::is_lock_free
bool is_lock_free() const volatile noexcept
volatile版本的检查是否支持无锁操作
定义 atomic.hpp:107

atomic::load
T load(const memory_order mo=memory_order_seq_cst) const volatile noexcept
volatile版本的原子加载操作
定义 atomic.hpp:137

atomic::compare_exchange_weak
bool compare_exchange_weak(T &expected, T desired, const memory_order success, const memory_order failure) noexcept
弱比较交换操作
定义 atomic.hpp:166

atomic::compare_exchange_strong
bool compare_exchange_strong(T &expected, T value, const memory_order mo=memory_order_seq_cst) volatile noexcept
volatile版本的简化版强比较交换操作
定义 atomic.hpp:238