The Linux Manuals (man pages) document is an important part of Linux documents. Linux Manuals are organized as several sections. Each section has a group of commands for a specific area in Linux usage, administration or development.
std::atomic_ref<T>::operatorT – std::atomic_ref<T>::operatorT Synopsis operator T() const noexcept; (since C++20) Atomically loads and returns the current value of the referenced object. Equivalent to load(). Parameters (none) Return value The current value of the referenced object. See also atomically obtains the value of the referenced object load (public member function)
std::atomic_ref<T>::operator= – std::atomic_ref<T>::operator= Synopsis T operator=(T desired) const noexcept; (1) atomic_ref & operator=(const atomic_ref &) = delete; (2) 1) Atomically assigns a value desired to the referenced object. Equivalent to store(desired). 2) atomic_ref is not CopyAssignable. Parameters desired – value to assign Return value desired. Notes Unlike most assignment operators, the assignment operator for atomic_ref…
std::atomic_ref<T>::operator++,++(int),–,–(int) – std::atomic_ref<T>::operator++,++(int),–,–(int) Synopsis member only of atomic_ref<Integral> and atomic_ref<T*> template specializations value_type operator++() const noexcept; (1) (since C++20) value_type operator++(int) const noexcept; (2) (since C++20) value_type operator–() const noexcept; (3) (since C++20) value_type operator–(int) const noexcept; (4) (since C++20) Atomically increments or decrements the current value of the referenced object. These operations are read-modify-write…
std::atomic_ref<T>::load – std::atomic_ref<T>::load Synopsis T load(std::memory_order order = std::memory_order_seq_cst) const noexcept; (since C++ 20) Atomically loads and returns the current value of the referenced object. 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 is undefined. Parameters order – memory order constraints…
std::atomic_ref<T>::is_lock_free – std::atomic_ref<T>::is_lock_free Synopsis bool is_lock_free() const noexcept; (since C++20) Checks whether the atomic operations on this object are lock-free. Parameters (none) Return value true if the atomic operations on this object are lock-free, false otherwise. Notes All atomic types except for std::atomic_flag may be implemented using mutexes or other locking operations, rather than using…
std::atomic_ref<T>::is_always_lock_free – std::atomic_ref<T>::is_always_lock_free Synopsis static constexpr bool is_always_lock_free = /*implementation-defined*/; (since C++20) Equals true if this operations on this atomic_ref type is always lock-free and false if it is never or sometimes lock-free. The value of this constant is consistent with the result of member function is_lock_free. See also checks if the atomic_ref object is…
std::atomic_ref<T>::fetch_xor – std::atomic_ref<T>::fetch_xor Synopsis T fetch_xor(T arg, (since C++ 20) std::memory_order order = std::memory_order_seq_cst) const noexcept; (member only of atomic_ref<Integral> template specialization) Atomically replaces the current value of the referenced object with the result of bitwise XOR of the value and arg. This operation is a read-modify-write operation. Memory is affected according to the value…
std::atomic_ref<T>::fetch_sub – std::atomic_ref<T>::fetch_sub Synopsis member only of atomic_ref<Integral> and atomic_ref<Floating> template specializations T fetch_sub(T arg, (1) std::memory_order order = std::memory_order_seq_cst) const noexcept; member only of atomic_ref<T *> template specialization T * fetch_sub(std::ptrdiff_t arg, (2) std::memory_order order = std::memory_order_seq_cst) const noexcept; Atomically replaces the current value of the referenced object with the result of arithmetic subtraction…
std::atomic_ref<T>::fetch_or – std::atomic_ref<T>::fetch_or Synopsis T fetch_or(T arg, (since C++ 20) std::memory_order order = std::memory_order_seq_cst) const noexcept; (member only of atomic_ref<Integral> template specialization) Atomically replaces the current value of the referenced object with the result of bitwise OR of the value and arg. This operation is a read-modify-write operation. Memory is affected according to the value…
std::atomic_ref<T>::fetch_and – std::atomic_ref<T>::fetch_and Synopsis T fetch_and(T arg, (since C++ 20) std::memory_order order = std::memory_order_seq_cst) const noexcept; (member only of atomic_ref<Integral> template specialization) Atomically replaces the current value of the referenced object with the result of bitwise AND of the value and arg. This operation is a read-modify-write operation. Memory is affected according to the value…
std::atomic_ref<T>::fetch_add – std::atomic_ref<T>::fetch_add Synopsis member only of atomic_ref<Integral> and atomic_ref<Floating> template specializations T fetch_add(T arg, (1) std::memory_order order = std::memory_order_seq_cst) const noexcept; member only of atomic_ref<T *> template specialization T * fetch_add(std::ptrdiff_t arg, (2) std::memory_order order = std::memory_order_seq_cst) const noexcept; Atomically replaces the current value of the referenced object with the result of arithmetic addition…
std::atomic_ref<T>::exchange – std::atomic_ref<T>::exchange Synopsis T exchange(T desired, std::memory_order order = std::memory_order_seq_cst) const noexcept; (since C++ 20) Atomically replaces the value of the referenced object with desired. The operation is a read-modify-write operation. Memory is affected according to the value of order. Parameters desired – value to assign order – memory order constraints to enforce Return…
std::atomic_ref<T>::compare_exchange_weak,std::atomic_ref<T>::compare_exchange_strong – std::atomic_ref<T>::compare_exchange_weak,std::atomic_ref<T>::compare_exchange_strong Synopsis bool compare_exchange_weak(T &expected, T desired, std::memory_order success, (1)(since C++ 20) std::memory_order failure) const noexcept; bool compare_exchange_weak(T &expected, T desired, std::memory_order order = (2)(since C++ 20) std::memory_order_seq_cst) const noexcept; bool compare_exchange_strong(T &expected, T desired, std::memory_order success, (3)(since C++ 20) std::memory_order failure) const noexcept; bool compare_exchange_strong(T &expected, T desired, std::memory_order order = (4)(since…
std::atomic_ref<T>::atomic_ref – std::atomic_ref<T>::atomic_ref Synopsis explicit atomic_ref( T& obj ); (1) (since C++20) atomic_ref( const atomic_ref& ref ) noexcept; (2) (since C++11) Constructs a new atomic_ref object. 1) Constructs an atomic_ref object referencing the object obj. The behavior is undefined if obj is not aligned to required_alignment. 2) Constructs an atomic_ref object referencing the object referenced…
std::atomic_ref – std::atomic_ref Synopsis Defined in header<atomic> template <class T> (1)(since C++ 20) struct atomic_ref; template <class T> (2)(since C++ 20) struct atomic_ref<T *>; The std::atomic_ref class template applies atomic operations to the object it references. For the lifetime of the atomic_ref object, the object it references is considered an atomic object. If one thread…
std::atomic_load,std::atomic_load_explicit – std::atomic_load,std::atomic_load_explicit Synopsis Defined in header<atomic> template <class T> T atomic_load(const std::atomic<T> *obj) noexcept; template <class T> T atomic_load(const volatile std::atomic<T> *obj) noexcept; template <class T> (1)(since C++ 11) T atomic_load_explicit(const std::atomic<T> *obj, std::memory_order order) noexcept; (2)(since C++ 11) template <class T> T atomic_load_explicit(const volatile std::atomic<T> *obj, std::memory_order order) noexcept; 1) Atomically obtains the…
std::atomic_is_lock_free,ATOMIC_xxx_LOCK_FREE – std::atomic_is_lock_free,ATOMIC_xxx_LOCK_FREE Synopsis Defined in header<atomic> template <class T> bool atomic_is_lock_free(const volatile std::atomic<T> *obj) noexcept; template <class T> bool atomic_is_lock_free(const std::atomic<T> *obj) noexcept; #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 */ (1)(since C++ 11) #define ATOMIC_WCHAR_T_LOCK_FREE /* unspecified */ (2)(since C++ 11)…
std::atomic_init – std::atomic_init Synopsis Defined in header<atomic> template <class T> void atomic_init(std::atomic<T> *obj, (since C++ 11) typename std::atomic<T>::value_type desired) noexcept; template <class T> void atomic_init(volatile std::atomic<T> *obj, (since C++ 11) typename std::atomic<T>::value_type desired) noexcept; Initializes the default-constructed atomic object obj with the value desired. The function is not atomic: concurrent access from another thread, even…
std::atomic_flag_test_and_set,std::atomic_flag_test_and_set_explicit – std::atomic_flag_test_and_set,std::atomic_flag_test_and_set_explicit Synopsis Defined in header <atomic> bool atomic_flag_test_and_set( volatile std::atomic_flag* p ) noexcept; bool atomic_flag_test_and_set( std::atomic_flag* p ) noexcept; bool atomic_flag_test_and_set_explicit( volatile std::atomic_flag* p, (1) (since C++11) std::memory_order order ) noexcept; (2) (since C++11) bool atomic_flag_test_and_set_explicit( std::atomic_flag* p, std::memory_order order ) noexcept; Atomically changes the state of a std::atomic_flag pointed to by p…
std::atomic_flag_clear,std::atomic_flag_clear_explicit – std::atomic_flag_clear,std::atomic_flag_clear_explicit Synopsis Defined in header<atomic> void atomic_flag_clear(volatile std::atomic_flag *p) noexcept; void atomic_flag_clear(std::atomic_flag *p) noexcept; void atomic_flag_clear_explicit(volatile std::atomic_flag *p, (1)(since C++ 11) std::memory_order order) noexcept; (2)(since C++ 11) void atomic_flag_clear_explicit(std::atomic_flag *p, std::memory_order order) noexcept; Atomically changes the state of a std::atomic_flag pointed to by p to clear (false). Parameters p – pointer to std::atomic_flag…