[atomics.ref.generic.general] (original) (raw)

32 Concurrency support library [thread]

32.5 Atomic operations [atomics]

32.5.7 Class template atomic_ref [atomics.ref.generic]

32.5.7.1 General [atomics.ref.generic.general]

namespace std { template<class T> struct atomic_ref { private: T* ptr; public: using value_type = remove_cv_t<T>;static constexpr size_t required_alignment = implementation-defined;static constexpr bool is_always_lock_free = implementation-defined;bool is_lock_free() const noexcept;constexpr explicit atomic_ref(T&);constexpr atomic_ref(const atomic_ref&) noexcept; atomic_ref& operator=(const atomic_ref&) = delete;constexpr void store(value_type, memory_order = memory_order::seq_cst) const noexcept;constexpr value_type operator=(value_type) const noexcept;constexpr value_type load(memory_order = memory_order::seq_cst) const noexcept;constexpr operator value_type() const noexcept;constexpr value_type exchange(value_type, memory_order = memory_order::seq_cst) const noexcept;constexpr bool compare_exchange_weak(value_type&, value_type, memory_order, memory_order) const noexcept;constexpr bool compare_exchange_strong(value_type&, value_type, memory_order, memory_order) const noexcept;constexpr bool compare_exchange_weak(value_type&, value_type, memory_order = memory_order::seq_cst) const noexcept;constexpr bool compare_exchange_strong(value_type&, value_type, memory_order = memory_order::seq_cst) const noexcept;constexpr void wait(value_type, memory_order = memory_order::seq_cst) const noexcept;constexpr void notify_one() const noexcept;constexpr void notify_all() const noexcept;constexpr T* address() const noexcept;};}

An atomic_ref object applies atomic operations ([atomics.general]) to the object referenced by *ptr such that, for the lifetime ([basic.life]) of the atomic_ref object, the object referenced by *ptr is an atomic object ([intro.races]).

The program is ill-formed if is_trivially_copyable_v<T> is false.

The lifetime ([basic.life]) of an object referenced by *ptrshall exceed the lifetime of all atomic_refs that reference the object.

While any atomic_ref instances exist that reference the *ptr object, all accesses to that object shall exclusively occur through those atomic_ref instances.

No subobject of the object referenced by atomic_refshall be concurrently referenced by any other atomic_ref object.

Atomic operations applied to an object through a referencing atomic_ref are atomic with respect to atomic operations applied through any other atomic_refreferencing the same object.

[Note 1:

Atomic operations or the atomic_ref constructor can acquire a shared resource, such as a lock associated with the referenced object, to enable atomic operations to be applied to the referenced object.

— _end note_]

The program is ill-formed if is_always_lock_free is false andis_volatile_v<T> is true.