Linux Manuals

std::atomic_flag::test_and_set – std::atomic_flag::test_and_set Synopsis Defined in header <atomic> bool test_and_set(std::memory_order order = std::memory_order_seq_cst) volatile noexcept; (1) (since C++11) bool test_and_set(std::memory_order order = std::memory_order_seq_cst) noexcept; (2) (since C++11) Atomically changes the state of a std::atomic_flag to set (true) and returns the value it held before. Parameters order – the memory synchronization ordering for this operation See…

std::atomic_flag::operator= – std::atomic_flag::operator= Synopsis Defined in header<atomic> atomic_flag &operator=(const atomic_flag &) = delete; (1)(since C++ 11) atomic_flag & operator=(const atomic_flag &) volatile = delete; (2)(since C++ 11) std::atomic_flag is not assignable, its assignment operators are deleted.

std::atomic_flag::clear – std::atomic_flag::clear Synopsis Defined in header<atomic> void clear(std::memory_order order = std::memory_order_seq_cst) volatile noexcept; (1)(since C++ 11) void clear(std::memory_order order = std::memory_order_seq_cst) noexcept; (2)(since C++ 11) Atomically changes the state of a std::atomic_flag to clear (false). Parameters order – the memory synchronization ordering for this operation (cannot be std::memory_order_consume, std::memory_order_acquire, or std::memory_order_acq_rel) See also                            atomically…

std::atomic_flag::atomic_flag – std::atomic_flag::atomic_flag Synopsis Defined in header<atomic> atomic_flag() noexcept; (1)(since C++ 11) atomic_flag(const atomic_flag &) = delete; (2)(since C++ 11) Constructs a new std::atomic_flag. 1) Trivial default constructor, initializes std::atomic_flag to unspecified state. 2) The copy constructor is deleted; std::atomic_flag is not copyable. In addition, std::atomic_flag can be value-initialized to clear state with the expression…

std::atomic_flag – std::atomic_flag Synopsis Defined in header <atomic> class atomic_flag; (since C++11) std::atomic_flag is an atomic boolean type. Unlike all specializations of std::atomic, it is guaranteed to be lock-free. Unlike std::atomic<bool>, std::atomic_flag does not provide load or store operations. Member functions               constructs an atomic_flag constructor (public member function)               the assignment operator operator= (public member function)…

std::atomic_fetch_xor,std::atomic_fetch_xor_explicit – std::atomic_fetch_xor,std::atomic_fetch_xor_explicit Synopsis Defined in header <atomic> template< class T > T atomic_fetch_xor( std::atomic<T>* obj, typename std::atomic<T>::value_type arg ) noexcept; template< class T > T atomic_fetch_xor( volatile std::atomic<T>* obj, typename std::atomic<T>::value_type arg ) noexcept; template< class T > (1) (since C++11) T atomic_fetch_xor_explicit( std::atomic<T>* obj, typename std::atomic<T>::value_type arg, std::memory_order order) noexcept; (2) (since C++11)…

std::atomic_fetch_sub,std::atomic_fetch_sub_explicit – std::atomic_fetch_sub,std::atomic_fetch_sub_explicit Synopsis Defined in header <atomic> template< class T > T atomic_fetch_sub( std::atomic<T>* obj, typename std::atomic<T>::difference_type arg ) noexcept; template< class T > T atomic_fetch_sub( volatile std::atomic<T>* obj, typename std::atomic<T>::difference_type arg ) noexcept; template< class T > (1) T atomic_fetch_sub_explicit( std::atomic<T>* obj, typename std::atomic<T>::difference_type arg, std::memory_order order ) noexcept; (2) template< class T…

std::atomic_fetch_or,std::atomic_fetch_or_explicit – std::atomic_fetch_or,std::atomic_fetch_or_explicit Synopsis Defined in header <atomic> template< class T > T atomic_fetch_or( std::atomic<T>* obj, typename std::atomic<T>::value_type arg ) noexcept; template< class T > T atomic_fetch_or( volatile std::atomic<T>* obj, typename std::atomic<T>::value_type arg ) noexcept; template< class T > (1) (since C++11) T atomic_fetch_or_explicit( std::atomic<T>* obj, typename std::atomic<T>::value_type arg, std::memory_order order) noexcept; (2) (since C++11)…

std::atomic_fetch_and,std::atomic_fetch_and_explicit – std::atomic_fetch_and,std::atomic_fetch_and_explicit Synopsis Defined in header <atomic> template< class T > T atomic_fetch_and( std::atomic<T>* obj, typename std::atomic<T>::value_type arg ) noexcept; template< class T > T atomic_fetch_and( volatile std::atomic<T>* obj, typename std::atomic<T>::value_type arg ) noexcept; template< class T > (1) (since C++11) T atomic_fetch_and_explicit( std::atomic<T>* obj, typename std::atomic<T>::value_type arg, std::memory_order order) noexcept; (2) (since C++11)…

std::atomic_fetch_add,std::atomic_fetch_add_explicit – std::atomic_fetch_add,std::atomic_fetch_add_explicit Synopsis Defined in header <atomic> template< class T > T atomic_fetch_add( std::atomic<T>* obj, typename std::atomic<T>::difference_type arg ) noexcept; template< class T > T atomic_fetch_add( volatile std::atomic<T>* obj, typename std::atomic<T>::difference_type arg ) noexcept; template< class T > (1) T atomic_fetch_add_explicit( std::atomic<T>* obj, typename std::atomic<T>::difference_type arg, std::memory_order order ) noexcept; (2) template< class T…

std::atomic_exchange,std::atomic_exchange_explicit – std::atomic_exchange,std::atomic_exchange_explicit Synopsis Defined in header <atomic> template< class T > T atomic_exchange( std::atomic<T>* obj, typename std::atomic<T>::value_type desr ) noexcept; template< class T > T atomic_exchange( volatile std::atomic<T>* obj, typename std::atomic<T>::value_type desr ) noexcept; template< class T > (1) (since C++11) T atomic_exchange_explicit( std::atomic<T>* obj, typename std::atomic<T>::value_type desr, std::memory_order order ) noexcept; (2) (since…

std::atomic_compare_exchange_weak,std::atomic_compare_exchange_strong,std::atomic_compare_exchange_weak_explicit,std::atomic_compare_exchange_strong_explicit – std::atomic_compare_exchange_weak,std::atomic_compare_exchange_strong,std::atomic_compare_exchange_weak_explicit,std::atomic_compare_exchange_strong_explicit Synopsis Defined in header <atomic> template< class T > bool atomic_compare_exchange_weak( std::atomic<T>* obj, typename std::atomic<T>::value_type* expected, typename std::atomic<T>::value_type desired ) noexcept; template< class T > bool atomic_compare_exchange_weak( volatile std::atomic<T>* obj, typename std::atomic<T>::value_type* expected, typename std::atomic<T>::value_type desired ) noexcept; template< class T > bool atomic_compare_exchange_strong( std::atomic<T>* obj, typename std::atomic<T>::value_type* expected, typename std::atomic<T>::value_type desired…

std::atomic_compare_exchange_weak,std::atomic_compare_exchange_strong, – std::atomic_compare_exchange_weak,std::atomic_compare_exchange_strong, Synopsis    Defined in header <atomic>    template< class T >    bool atomic_compare_exchange_weak(    std::atomic<T>* obj,    typename std::atomic<T>::value_type*    expected,    typename std::atomic<T>::value_type    desired ) noexcept;    template< class T >    bool atomic_compare_exchange_weak(    volatile std::atomic<T>* obj,    typename std::atomic<T>::value_type*    expected,    typename std::atomic<T>::value_type    desired ) noexcept;    template< class T >    bool atomic_compare_exchange_strong(    std::atomic<T>* obj,    typename std::atomic<T>::value_type*    expected,    typename std::atomic<T>::value_type    desired ) noexcept;    template< class T >    bool atomic_compare_exchange_strong(    volatile std::atomic<T>* obj,    typename std::atomic<T>::value_type*    expected,    typename std::atomic<T>::value_type    desired ) noexcept;    template< class T >…

std::atomic_bool – Synopsis Inherited by std::atomic< bool >. Public Member Functions atomic_bool (const atomic_bool &)=delete constexpr atomic_bool (bool __i) noexcept bool compare_exchange_strong (bool &__i1, bool __i2, memory_order __m1, memory_order __m2) noexcept bool compare_exchange_strong (bool &__i1, bool __i2, memory_order __m1, memory_order __m2) volatilenoexcept bool compare_exchange_strong (bool &__i1, bool __i2, memory_order __m=memory_order_seq_cst) noexcept bool compare_exchange_strong (bool &__i1,…

std::atomic_…<std::shared_ptr> – std::atomic_…<std::shared_ptr> Synopsis template <class T> (1)(since C++ 11) bool atomic_is_lock_free(const std::shared_ptr<T> *p); (deprecated in C++ 20) template <class T> (2)(since C++ 11) std::shared_ptr<T> atomic_load(const std::shared_ptr<T> *p); (deprecated in C++ 20) template <class T> (since C++ 11) std::shared_ptr<T> atomic_load_explicit(const std::shared_ptr<T> *p, (3)(deprecated in C++ 20) std::memory_order mo); template <class T> (since C++ 11) void…

std::atomic<T>::store – std::atomic<T>::store Synopsis void store(T desired, std::memory_order order = std::memory_order_seq_cst) noexcept; (since C++ 11) void store(T desired, std::memory_order order = std::memory_order_seq_cst) volatile noexcept; Atomically replaces the current value with desired. Memory is affected according to the value of order. order must be one of std::memory_order_relaxed, std::memory_order_release or std::memory_order_seq_cst. Otherwise the behavior is undefined. Parameters…

std::atomic<T>::operatorT – std::atomic<T>::operatorT Synopsis operator T() const noexcept; (since C++ 11) operator T() const volatile noexcept; Atomically loads and returns the current value of the atomic variable. Equivalent to load(). Parameters (none) Return value The current value of the atomic variable. See also      atomically obtains the value of the atomic object load (public member function)

std::atomic<T>::operator= – std::atomic<T>::operator= Synopsis T operator=(T desired) noexcept; T operator=(T desired) volatile noexcept; (1)(since C++ 11)(1)(since C++ 11) atomic & operator=(const atomic &) = delete; (2)(since C++ 11) atomic & operator=(const atomic &) volatile = delete; 1) Atomically assigns a value desired to the atomic variable. Equivalent to store(desired). 2) Atomic variables are not CopyAssignable….

std::atomic<T>::operator++,++(int),–,–(int) – std::atomic<T>::operator++,++(int),–,–(int) Synopsis T operator++() noexcept; (1) (member only of atomic<Integral> template specialization) T operator++() volatile noexcept; (since C++11) T* operator++() noexcept; (1) (member only of atomic<T*> template specialization) T* operator++() volatile noexcept; (since C++11) T operator++( int ) noexcept; (2) (member only of atomic<Integral> template specialization) T operator++( int ) volatile noexcept; (since…

std::atomic<T>::load – std::atomic<T>::load Synopsis T load(std::memory_order order = std::memory_order_seq_cst) const noexcept; (since C++ 11) T load(std::memory_order order = std::memory_order_seq_cst) const volatile noexcept; Atomically loads and returns the current value of the atomic variable. Memory is affected according to the value of order. order must be one of std::memory_order_relaxed, std::memory_order_consume, std::memory_order_acquire or std::memory_order_seq_cst. Otherwise the behavior…