Defined in header <atomic> (1) (since C++11) template< class T > T atomic_load( const std::atomic<T>* obj ); template< class T > T atomic_load( const volatile std::atomic<T>* obj ); (2) (since C++11) template< class T > T atomic_load_explicit( const std::atomic<T>* obj, std::memory_order order ); template< class T > T atomic_load_explicit( const volatile std::atomic<T>* obj,

Defined in header <atomic> (1) (since C++11) void atomic_flag_clear( volatile std::atomic_flag* p ); void atomic_flag_clear( std::atomic_flag* p ); (2) (since C++11) void atomic_flag_clear_explicit( volatile std::atomic_flag* p, std::memory_order order ); void atomic_flag_clear_explicit( std::atomic_flag* p, std::memory_order order ); Atomically changes the state of a std::atomic_flag po

Defined in header <atomic> bool test_and_set(std::memory_order order = std::memory_order_seq_cst) volatile; (1) (since C++11) bool test_and_set(std::memory_order order = std::memory_order_seq_cst); (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 Exceptions noexcept specification: noexcept See also clear

Defined in header <atomic> void clear( std::memory_order order = std::memory_order_seq_cst ) volatile; (1) (since C++11) void clear( std::memory_order order = std::memory_order_seq_cst ); (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) Exceptions no

Defined in header <atomic> (1) (since C++11) bool atomic_flag_test_and_set( volatile std::atomic_flag* p ); bool atomic_flag_test_and_set( std::atomic_flag* p ); (2) (since C++11) bool atomic_flag_test_and_set_explicit( volatile std::atomic_flag* p, std::memory_order order ); bool atomic_flag_test_and_set_explicit( std::atomic_flag* p, std::memory_order order ); Atomically

Defined in header <atomic> atomic_flag(); (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 ATOMIC_FLAG_INIT. For an atomic_flag with static storage duration, t

Defined in header <atomic> (1) (since C++11) template< class Integral > Integral atomic_fetch_xor( std::atomic<Integral>* obj, Integral arg ); template< class Integral > Integral atomic_fetch_xor( volatile std::atomic<Integral>* obj, Integral arg ); (2) (since C++11) template< class Integral > Integral atomic_fetch_xor_explicit( std::atomic<Integral>* obj, Integral arg, std::memory_order order

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 (constructor) constructs an atomic_flag (public member function) operator= the assignment operator (public member function) clear atomically sets flag to false (public me

Defined in header <atomic> (1) (since C++11) template< class Integral > Integral atomic_fetch_or( std::atomic<Integral>* obj, Integral arg ); template< class Integral > Integral atomic_fetch_or( volatile std::atomic<Integral>* obj, Integral arg ); (2) (since C++11) template< class Integral > Integral atomic_fetch_or_explicit( std::atomic<Integral>* obj, Integral arg,

Defined in header <atomic> (1) (since C++11) template< class Integral > Integral atomic_fetch_and( std::atomic<Integral>* obj, Integral arg ); template< class Integral > Integral atomic_fetch_and( volatile std::atomic<Integral>* obj, Integral arg ); (2) (since C++11) template< class Integral > Integral atomic_fetch_and_explicit( std::atomic<Integral>* obj, Integral arg,