The std::atomic
class provides a wrapper with atomic operations for any type that satisfies
the requirements below.
The template parameter BaseType
must:
- have a trivial default constructor
- have a trivial copy-assignment operator
- have a trivial destructor
- be bitwise-equality-comparable
This basically means that std::atomic<some-built-in-type> is fine, as is std::atomic<some-simple-struct>, but things like std::atomic<std::string> are not.
In addition to the primary template, there are specializations for the
built-in arithmetic types to provide additional operations such as x++.
Instances of std::atomic
are not CopyConstructible or CopyAssignable, as these operations cannot
be performed as a single atomic operation.
template<typename BaseType> struct atomic { atomic() = default; constexpr atomic(BaseType); BaseType operator=(BaseType) volatile; atomic(const atomic&) = delete; atomic& operator=(const atomic&) = delete; bool is_lock_free() const volatile; void store(BaseType,memory_order = memory_order_seq_cst) volatile; BaseType load(memory_order = memory_order_seq_cst) const volatile; BaseType exchange(BaseType,memory_order = memory_order_seq_cst) volatile; bool compare_exchange_strong(BaseType & old_value, BaseType new_value, memory_order order = memory_order_seq_cst) volatile; bool compare_exchange_strong(BaseType & old_value, BaseType new_value, memory_order success_order, memory_order failure_order) volatile; bool compare_exchange_weak(BaseType & old_value, BaseType new_value, memory_order order = memory_order_seq_cst) volatile; bool compare_exchange_weak(BaseType & old_value, BaseType new_value, memory_order success_order, memory_order failure_order) volatile; operator BaseType () const volatile; }; bool atomic_is_lock_free(volatile const atomic*); BaseType atomic_exchange(volatile atomic*, memory_order); BaseType atomic_exchange_explicit(volatile atomic*, memory_order); void atomic_store(volatile atomic*, memory_order); void atomic_store_explicit(volatile atomic*, memory_order); BaseType atomic_load(volatile const atomic*); BaseType atomic_load_explicit(volatile const atomic*, memory_order); bool atomic_compare_exchange_strong(volatile atomic*,BaseType * old_value, BaseType new_value); bool atomic_compare_exchange_strong_explicit(volatile atomic*,BaseType * old_value, BaseType new_value, memory_order success_order, memory_order failure_order); bool atomic_compare_exchange_weak(volatile atomic*,BaseType * old_value, BaseType new_value); bool atomic_compare_exchange_weak_explicit(volatile atomic*,BaseType * old_value, BaseType new_value, memory_order success_order, memory_order failure_order);
Header
#include <atomic>