Linux Manuals session 3

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…

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)…