# constexpr atomic<T> and atomic_ref<T>

## Introduction and motivation

This paper proposes marking most of `atomic<T>`

methods and associated functions `constexpr`

to allow usage of atomic code without changes in a constexpr and consteval code.

Proposed changes will allow implementing other types (`std::shared_ptr<T>`

, persistent data structures with atomic pointers) and algorithms (thread safe data-processing, like scanning data with atomic counter) with just sprinkling `constexpr`

to their specification.

## Changes

- R1 → R2: Added clarification for behaviour of
`wait`

and`notify`

functions. - R0 → R1: Make
`wait`

and`notify`

functions as requested by SG1. Wording changed accordingly. Updaded link to implementation on Compiler Explorer.

## Previous polls

SG1: Forward P3309 to LEWG with the following notes:- Add constexpr to the wait and notify functions in the next revision of P3309
`atomic<shared_ptr>`

should be supported in constexpr whenever`shared_ptr`

is supported in constexpr (whichever paper lands second should have this change)`is_lock_free()`

should not be made constexpr

SF | F | N | A | SA |
---|---|---|---|---|

2 | 10 | 4 | 0 | 0 |

## Intention for wording changes

Mark all functions in [atomics] constexpr excluding all `volatile`

overloads. As all these can be implemented in constant expression evaluator or using `if consteval`

:

```
template<class T>
constexpr T atomic_fetch_add(atomic<T>* target, typename atomic<T>::difference_type diff) noexcept {
if consteval {
const auto previous = target->value;
target->value += diff;
return previous;
} else {
return __c11_atomic_fetch_add(&target->value, diff);
}
}
```

Synchronization functions and helpers can be implemented as no-ops (`std::kill_dependency`

, `std::atomic_thread_fence`

). Memory order parameters should be just ignored as `constant evaluated`

code doesn't have multiple threads.

Alternative implementation strategy is to allow atomic builtins to work in constant evaluator.

`wait`

and `notify`

behaviour

`Wait`

and `notify`

operations should work during constant evaluation as expected in a single-threaded environment. `Notify`

will be noop and `wait`

-ing for a different value will be a deadlock which should result in constant evaluation failure according to [expr.const#5.7] *an expression that would exceed the implementation-defined limits* as every check for the value
is considered [intro.progress#4] *continous executing of execution steps while waiting for the condition**.*

*
namespace std {
// [atomics.order], order and consistency
enum class memory_order :
The type aliases atomic_intN_t, atomic_uintN_t,
atomic_intptr_t, and atomic_uintptr_t
are defined if and only if
intN_t, uintN_t,
intptr_t, and uintptr_t
are defined, respectively.The type aliases
atomic_signed_lock_free and atomic_unsigned_lock_free
name specializations of atomic
whose template arguments are integral types, respectively signed and unsigned,
and whose is_always_lock_free property is true.
Implementations should choose for these aliases
the integral specializations of atomic
for which the atomic waiting and notifying operations ([atomics.wait])
are most efficient.
namespace std {
enum class memory_order : The enumeration memory_order specifies the detailed regular
(non-atomic) memory synchronization order as defined in
[intro.multithread] and may provide for operation ordering. Its
enumerated values and their meanings are as follows:An atomic operation A that performs a release operation on an atomic
object M synchronizes with an atomic operation B that performs
an acquire operation on M and takes its value from any side effect in the
release sequence headed by A.An atomic operation A on some atomic object M is
There is a single total order S
on all memory_order::seq_cst operations, including fences,
that satisfies the following constraints. First, if A and B are
memory_order::seq_cst operations and
A strongly happens before B,
then A precedes B in S. Second, for every pair of atomic operations A and
B on an object M,
where A is coherence-ordered before B,
the following four conditions are required to be satisfied by S:
[memory_order::seq_cst ensures sequential consistency only
for a program that is free of data races and
uses exclusively memory_order::seq_cst atomic operations. Any use of weaker ordering will invalidate this guarantee
unless extreme care is used. In many cases, memory_order::seq_cst atomic operations are reorderable
with respect to other atomic operations performed by the same thread. — Implementations should ensure that no “out-of-thin-air” values are computed that
circularly depend on their own computation.[For example, with x and y initially zero,
// Thread 1:
r1 = y.load(memory_order::relaxed);
x.store(r1, memory_order::relaxed);
// Thread 2:
r2 = x.load(memory_order::relaxed);
y.store(r2, memory_order::relaxed);
this recommendation discourages producing r1 == r2 == 42, since the store of 42 to y is only
possible if the store to x stores 42, which circularly depends on the
store to y storing 42. Note that without this restriction, such an
execution is possible. — [The recommendation similarly disallows r1 == r2 == 42 in the
following example, with x and y again initially zero:// Thread 1:
r1 = x.load(memory_order::relaxed);
if (r1 == 42) y.store(42, memory_order::relaxed);
// Thread 2:
r2 = y.load(memory_order::relaxed);
if (r2 == 42) x.store(42, memory_order::relaxed);
— Atomic read-modify-write operations shall always read the last value
(in the modification order) written before the write associated with
the read-modify-write operation.
#define ATOMIC_BOOL_LOCK_FREE The ATOMIC_..._LOCK_FREE macros indicate the lock-free property of the
corresponding atomic types, with the signed and unsigned variants grouped
together. The properties also apply to the corresponding (partial) specializations of the
atomic template. A value of 0 indicates that the types are never
lock-free. A value of 1 indicates that the types are sometimes lock-free. A
value of 2 indicates that the types are always lock-free.On a hosted implementation ([compliance]),
at least one signed integral specialization of the atomic template,
along with the specialization
for the corresponding unsigned type ([basic.fundamental]),
is always lock-free.The functions atomic<T>::is_lock_free and
atomic_is_lock_free ([atomics.types.operations])
indicate whether the object is lock-free. In any given program execution, the
result of the lock-free query
is the same for all atomic objects of the same type.
The implementation of these operations should not depend on any per-process state.
An atomic waiting operation may block until it is unblocked
by an atomic notifying operation, according to each function's effects. [The following functions are atomic notifying operations:
— A call to an atomic waiting operation on an atomic object M
is
namespace std {
template<class T> struct atomic_ref {
private:
T* ptr; // 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 lifetime ([basic.life]) of an object referenced by *ptr
shall 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_ref
shall 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_ref
referencing the same object. [Hardware could require an object
referenced by an atomic_ref
to have stricter alignment ([basic.align])
than other objects of type T. Further, whether operations on an atomic_ref
are lock-free could depend on the alignment of the referenced object. For example, lock-free operations on std::complex<double>
could be supported only if aligned to 2*alignof(double). — Memory is affected according to the value of order. This operation is an atomic read-modify-write operation ([intro.multithread]). It then atomically compares the value representation of
the value referenced by *ptr for equality
with that previously retrieved from expected,
and if true, replaces the value referenced by *ptr
with that in desired. If and only if the comparison is true,
memory is affected according to the value of success, and
if the comparison is false,
memory is affected according to the value of failure. When only one memory_order argument is supplied,
the value of success is order, and
the value of failure is order
except that a value of memory_order::acq_rel shall be replaced by
the value memory_order::acquire and
a value of memory_order::release shall be replaced by
the value memory_order::relaxed. If and only if the comparison is false then,
after the atomic operation,
the value in expected is replaced by
the value read from the value referenced by *ptr
during the atomic comparison. If the operation returns true,
these operations are atomic read-modify-write operations ([intro.races])
on the value referenced by *ptr. Otherwise, these operations are atomic load operations on that memory. That is, even when the contents of memory referred to
by expected and ptr are equal,
it may return false and
store back to expected the same memory contents
that were originally there. [This spurious failure enables implementation of compare-and-exchange
on a broader class of machines, e.g., load-locked store-conditional machines. A consequence of spurious failure is
that nearly all uses of weak compare-and-exchange will be in a loop. When a compare-and-exchange is in a loop,
the weak version will yield better performance on some platforms. When a weak compare-and-exchange would require a loop and
a strong one would not, the strong one is preferable. — There are specializations of the atomic_ref class template
for the integral types
char,
signed char,
unsigned char,
short,
unsigned short,
int,
unsigned int,
long,
unsigned long,
long long,
unsigned long long,
char8_t,
char16_t,
char32_t,
wchar_t,
and any other types needed by the typedefs in the header <cstdint>. For each such type [namespace std {
template<> struct atomic_ref< Memory is affected according to the value of order. These operations are atomic read-modify-write operations ([intro.races]). For fetch_max and fetch_min, the maximum and minimum
computation is performed as if by max and min algorithms
([alg.min.max]), respectively, with the object value and the first
parameter as the arguments.There are specializations of the atomic_ref class template
for all cv-unqualified floating-point types. For each such type namespace std {
template<> struct atomic_ref< Memory is affected according to the value of order. These operations are atomic read-modify-write operations ([intro.races]). Atomic arithmetic operations on
namespace std {
template<class T> struct atomic_ref<T*> {
private:
T** ptr; // Memory is affected according to the value of order. These operations are atomic read-modify-write operations ([intro.races]).For fetch_max and fetch_min, the maximum and minimum
computation is performed as if by max and min
algorithms ([alg.min.max]), respectively, with the object value and the first
parameter as the arguments.[If the pointers point to different complete objects (or subobjects thereof),
the < operator does not establish a strict weak ordering
(Table 29, [expr.rel]). —
namespace std {
template<class T> struct atomic {
using value_type = T;
static constexpr bool is_always_lock_free = Initialization is not an atomic operation ([intro.multithread]). Initialization is not an atomic operation ([intro.multithread]). [It is possible to have an access to an atomic object A
race with its construction, for example by communicating the address of the
just-constructed object A to another thread via
memory_order::relaxed operations on a suitable atomic pointer
variable, and then immediately accessing A in the receiving thread. This results in undefined behavior. — Memory is affected according to the value of order. These operations are atomic read-modify-write operations ([intro.multithread]). It then atomically
compares the value representation of the value pointed to by this
for equality with that previously retrieved from expected,
and if true, replaces the value pointed to
by this with that in desired. If and only if the comparison is true, memory is affected according to the
value of success, and if the comparison is false, memory is affected according
to the value of failure. When only one memory_order argument is
supplied, the value of success is order, and the value of
failure is order except that a value of memory_order::acq_rel
shall be replaced by the value memory_order::acquire and a value of
memory_order::release shall be replaced by the value
memory_order::relaxed. If and only if the comparison is false then, after the atomic operation,
the value in expected is replaced by the value
pointed to by this during the atomic comparison. If the operation returns true, these
operations are atomic read-modify-write
operations ([intro.multithread]) on the memory
pointed to by this. Otherwise, these operations are atomic load operations on that memory.[For example, the effect of
compare_exchange_strong
on objects without padding bits ([basic.types.general]) is
if (memcmp(this, &expected, sizeof(*this)) == 0)
memcpy(this, &desired, sizeof(*this));
else
memcpy(&expected, this, sizeof(*this));
— [The expected use of the compare-and-exchange operations is as follows. The
compare-and-exchange operations will update expected when another iteration of
the loop is needed. expected = current.load();
do {
desired = function(expected);
} while (!current.compare_exchange_weak(expected, desired));
— [Because the expected value is updated only on failure,
code releasing the memory containing the expected value on success will work. For example, list head insertion will act atomically and would not introduce a
data race in the following code:
do {
p->next = head; // make new list node point to the current head
} while (!head.compare_exchange_weak(p->next, p)); // try to insert
— That is, even when
the contents of memory referred to by expected and this are
equal, it may return false and store back to expected the same memory
contents that were originally there. [This
spurious failure enables implementation of compare-and-exchange on a broader class of
machines, e.g., load-locked store-conditional machines. A
consequence of spurious failure is that nearly all uses of weak compare-and-exchange
will be in a loop. When a compare-and-exchange is in a loop, the weak version will yield better performance
on some platforms. When a weak compare-and-exchange would require a loop and a strong one
would not, the strong one is preferable. — [Under cases where the memcpy and memcmp semantics of the compare-and-exchange
operations apply, the comparisons can fail for values that compare equal with
operator== if the value representation has trap bits or alternate
representations of the same value. Notably, on implementations conforming to
ISO/IEC/IEEE 60559, floating-point -0.0 and +0.0
will not compare equal with memcmp but will compare equal with operator==,
and NaNs with the same payload will compare equal with memcmp but will not
compare equal with operator==. — [Because compare-and-exchange acts on an object's value representation,
padding bits that never participate in the object's value representation
are ignored. As a consequence, the following code is guaranteed to avoid
spurious failure:
struct padded {
char clank = 0x42;
// Padding here.
unsigned biff = 0xC0DEFEFE;
};
atomic<padded> pad = {};
bool zap() {
padded expected, desired{0, 0};
return pad.compare_exchange_strong(expected, desired);
}
— [For a union with bits that participate in the value representation
of some members but not others, compare-and-exchange might always fail. This is because such padding bits have an indeterminate value when they
do not participate in the value representation of the active member. As a consequence, the following code is not guaranteed to ever succeed:
union pony {
double celestia = 0.;
short luna; // padded
};
atomic<pony> princesses = {};
bool party(pony desired) {
pony expected;
return princesses.compare_exchange_strong(expected, desired);
}
— There are specializations of the atomic
class template for the integral types
char,
signed char,
unsigned char,
short,
unsigned short,
int,
unsigned int,
long,
unsigned long,
long long,
unsigned long long,
char8_t,
char16_t,
char32_t,
wchar_t,
and any other types needed by the typedefs in the header <cstdint>. For each such type [namespace std {
template<> struct atomic<The following operations perform arithmetic computations. Memory is affected according to the value of order. These operations are atomic read-modify-write operations ([intro.multithread]). For fetch_max and fetch_min, the maximum and minimum
computation is performed as if by max and min algorithms
([alg.min.max]), respectively, with the object value and the first parameter
as the arguments.There are specializations of the atomic
class template for all cv-unqualified floating-point types. For each such type namespace std {
template<> struct atomic< Memory is affected according to the value of order. These operations are atomic read-modify-write operations ([intro.multithread]). Atomic arithmetic operations on Atomic arithmetic operations on
namespace std {
template<class T> struct atomic<T*> {
using value_type = T*;
using difference_type = ptrdiff_t;
static constexpr bool is_always_lock_free = The following operations perform pointer arithmetic. Table 149: Atomic pointer computations [tab:atomic.types.pointer.comp]*

Memory is affected according to the value of order. These operations are atomic read-modify-write operations ([intro.multithread]).For fetch_max and fetch_min, the maximum and minimum
computation is performed as if by max and min
algorithms ([alg.min.max]), respectively, with the object value and the first
parameter as the arguments.[If the pointers point to different complete objects (or subobjects thereof),
the < operator does not establish a strict weak ordering
(Table 29, [expr.rel]). — The library provides partial specializations of the atomic template
for shared-ownership smart pointers ([util.sharedptr]).
The behavior of all operations is as specified in [atomics.types.generic],
unless specified otherwise. The template parameter T of these partial specializations
may be an incomplete type.All changes to an atomic smart pointer in [util.smartptr.atomic], and
all associated use_count increments,
are guaranteed to be performed atomically. Associated use_count decrements
are sequenced after the atomic operation,
but are not required to be part of it. Any associated deletion and deallocation
are sequenced after the atomic update step and
are not part of the atomic operation. [namespace std {
template<class T> struct atomic<weak_ptr<T>> {
using value_type = weak_ptr<T>;
static constexpr bool is_always_lock_free = Initialization is not an atomic operation ([intro.multithread]). [It is possible to have an access to
an atomic object A race with its construction,
for example,
by communicating the address of the just-constructed object A
to another thread via memory_order::relaxed operations
on a suitable atomic pointer variable, and
then immediately accessing A in the receiving thread. This results in undefined behavior. — Memory is affected according to the value of order. This is an atomic read-modify-write operation ([intro.races]).If the operation returns true,
expected is not accessed after the atomic update and
the operation is an atomic read-modify-write operation ([intro.multithread])
on the memory pointed to by this. Otherwise, the operation is an atomic load operation on that memory, and
expected is updated with the existing value
read from the atomic object in the attempted atomic update. The write to expected itself
is not required to be part of the atomic operation. This function is an atomic waiting operation ([atomics.wait]).
A non-member function template whose name matches the pattern
atomic_ An argument
for a parameter of type atomic<T>::value_type* is dereferenced when
passed to the member function call. If no such member function exists, the program is ill-formed.
namespace std {
struct atomic_flag {
constexpr atomic_flag() noexcept;
atomic_flag(const atomic_flag&) = delete;
atomic_flag& operator=(const atomic_flag&) = delete;
atomic_flag& operator=(const atomic_flag&) volatile = delete;
bool test(memory_order = memory_order::seq_cst) const volatile noexcept;
constexpr bool test(memory_order = memory_order::seq_cst) const noexcept;
bool test_and_set(memory_order = memory_order::seq_cst) volatile noexcept;
constexpr bool test_and_set(memory_order = memory_order::seq_cst) noexcept;
void clear(memory_order = memory_order::seq_cst) volatile noexcept;
constexpr void clear(memory_order = memory_order::seq_cst) noexcept;
void wait(bool, memory_order = memory_order::seq_cst) const volatile noexcept;
constexpr void wait(bool, memory_order = memory_order::seq_cst) const noexcept;
void notify_one() volatile noexcept;
constexpr void notify_one() noexcept;
void notify_all() volatile noexcept;
constexpr void notify_all() noexcept;
};
}
Memory is affected according to the value of
order. These operations are atomic read-modify-write operations ([intro.multithread]). The macro can be used in the form:
atomic_flag guard = ATOMIC_FLAG_INIT;
It is unspecified whether the macro can be used
in other initialization contexts. For a complete static-duration object, that initialization shall be static.
Fences can have
acquire semantics, release semantics, or both. A fence with acquire semantics is called
an A fence with release semantics is called a A release fence A synchronizes with an acquire fence B if there exist
atomic operations X and Y, both operating on some atomic object
M, such that A is sequenced before X, X modifies
M, Y is sequenced before B, and Y reads the value
written by X or a value written by any side effect in the hypothetical release
sequence X would head if it were a release operation.A release fence A synchronizes with an atomic operation B that
performs an acquire operation on an atomic object M if there exists an atomic
operation X such that A is sequenced before X, X
modifies M, and B reads the value written by X or a value
written by any side effect in the hypothetical release sequence X would head if
it were a release operation.An atomic operation A that is a release operation on an atomic object
M synchronizes with an acquire fence B if there exists some atomic
operation X on M such that X is sequenced before B
and reads the value written by A or a value written by any side effect in the
release sequence headed by A.[atomic_signal_fence can be used to specify the order in which actions
performed by the thread become visible to the signal handler. Compiler optimizations and reorderings of loads and stores are inhibited in
the same way as with atomic_thread_fence, but the hardware fence instructions
that atomic_thread_fence would have inserted are not emitted. —
The header <stdatomic.h> provides the following definitions:template<class T>
using Each Each of the Neither the _Atomic macro,
nor any of the non-macro global namespace declarations,
are provided by any C++ standard library header
other than <stdatomic.h>. The representations should be the same, and
the mechanisms used to ensure atomicity and memory ordering
should be compatible.

### Question answered by SG1

- Should we make
`is_lock_free`

functions also constexpr? No, keep it non-constexpr as it can be different on running environment.

### Question for LEWG

- Should we make
`atomic<shared_ptr<T>>`

and`atomic<weak_ptr<T>>`

constexpr? (paper's wording contains this change)There is associated paper P3037R1 making

`shared_ptr<T>`

constexpr.

## Example

This example shows how you can easily reuse code between runtime and constant evaluated code without duplication. Without this paper you need to duplicate multiple functions.

```
constexpr bool process_first_unprocessed(std::atomic<size_t> & counter, std::span<cell> subject) {
// BEFORE: compile-time error when you try to evaluate this inside constant evaluated code
// AFTER: work sequentialy in constant-evaluated code
const size_t current = counter.fetch_add(1);
if (current >= subject.size()) {
return false;
}
process(subject[current]);
return true;
}
constexpr void process_all(std::span<cell> subject, unsigned thread_count = 1) {
// BEFORE: calling following function in constant evaluated code will always fail with any number of requested threads
// AFTER: calling it with argument thread_count == 1 will succeed in constant evaluated code
std::atomic<size_t> counter{0};
auto threads = std::vector<std::jthread>{};
assert(thread_count >= 1);
for (unsigned i = 1; i < thread_count; ++i) {
threads.emplace_back([&]{
while (process_first_unprocessed(counter, subject));
});
}
while (process_first_unprocessed(counter, subject));
}
```

link to compiler-explorer.com
## Proposed changes to wording

# 33 Concurrency support library [thread]

## 33.5 Atomic operations [atomics]

### 33.5.1 General [atomics.general]

### 33.5.2 Header <atomic> synopsis [atomics.syn]

*unspecified*; // freestanding inline constexpr memory_order memory_order_relaxed = memory_order::relaxed; // freestanding inline constexpr memory_order memory_order_consume = memory_order::consume; // freestanding inline constexpr memory_order memory_order_acquire = memory_order::acquire; // freestanding inline constexpr memory_order memory_order_release = memory_order::release; // freestanding inline constexpr memory_order memory_order_acq_rel = memory_order::acq_rel; // freestanding inline constexpr memory_order memory_order_seq_cst = memory_order::seq_cst; // freestanding template<class T> constexpr T kill_dependency(T y) noexcept; // freestanding } // [atomics.lockfree], lock-free property #define ATOMIC_BOOL_LOCK_FREE

*unspecified*// freestanding #define ATOMIC_CHAR_LOCK_FREE

*unspecified*// freestanding #define ATOMIC_CHAR8_T_LOCK_FREE

*unspecified*// freestanding #define ATOMIC_CHAR16_T_LOCK_FREE

*unspecified*// freestanding #define ATOMIC_CHAR32_T_LOCK_FREE

*unspecified*// freestanding #define ATOMIC_WCHAR_T_LOCK_FREE

*unspecified*// freestanding #define ATOMIC_SHORT_LOCK_FREE

*unspecified*// freestanding #define ATOMIC_INT_LOCK_FREE

*unspecified*// freestanding #define ATOMIC_LONG_LOCK_FREE

*unspecified*// freestanding #define ATOMIC_LLONG_LOCK_FREE

*unspecified*// freestanding #define ATOMIC_POINTER_LOCK_FREE

*unspecified*// freestanding namespace std { // [atomics.ref.generic], class template atomic_ref template<class T> struct atomic_ref; // freestanding // [atomics.ref.pointer], partial specialization for pointers template<class T> struct atomic_ref<T*>; // freestanding // [atomics.types.generic], class template atomic template<class T> struct atomic; // freestanding // [atomics.types.pointer], partial specialization for pointers template<class T> struct atomic<T*>; // freestanding // [atomics.nonmembers], non-member functions template<class T> bool atomic_is_lock_free(const volatile atomic<T>*) noexcept; // freestanding template<class T> bool atomic_is_lock_free(const atomic<T>*) noexcept; // freestanding template<class T> void atomic_store(volatile atomic<T>*, // freestanding typename atomic<T>::value_type) noexcept; template<class T> constexpr void atomic_store(atomic<T>*, typename atomic<T>::value_type) noexcept; // freestanding template<class T> void atomic_store_explicit(volatile atomic<T>*, // freestanding typename atomic<T>::value_type, memory_order) noexcept; template<class T> constexpr void atomic_store_explicit(atomic<T>*, typename atomic<T>::value_type, // freestanding memory_order) noexcept; template<class T> T atomic_load(const volatile atomic<T>*) noexcept; // freestanding template<class T> constexpr T atomic_load(const atomic<T>*) noexcept; // freestanding template<class T> T atomic_load_explicit(const volatile atomic<T>*, memory_order) noexcept; // freestanding template<class T> constexpr T atomic_load_explicit(const atomic<T>*, memory_order) noexcept; // freestanding template<class T> T atomic_exchange(volatile atomic<T>*, // freestanding typename atomic<T>::value_type) noexcept; template<class T> constexpr T atomic_exchange(atomic<T>*, typename atomic<T>::value_type) noexcept; // freestanding template<class T> T atomic_exchange_explicit(volatile atomic<T>*, // freestanding typename atomic<T>::value_type, memory_order) noexcept; template<class T> constexpr T atomic_exchange_explicit(atomic<T>*, typename atomic<T>::value_type, // freestanding memory_order) noexcept; template<class T> bool atomic_compare_exchange_weak(volatile atomic<T>*, // freestanding typename atomic<T>::value_type*, typename atomic<T>::value_type) noexcept; template<class T> constexpr bool atomic_compare_exchange_weak(atomic<T>*, // freestanding typename atomic<T>::value_type*, typename atomic<T>::value_type) noexcept; template<class T> bool atomic_compare_exchange_strong(volatile atomic<T>*, // freestanding typename atomic<T>::value_type*, typename atomic<T>::value_type) noexcept; template<class T> constexpr bool atomic_compare_exchange_strong(atomic<T>*, // freestanding typename atomic<T>::value_type*, typename atomic<T>::value_type) noexcept; template<class T> bool atomic_compare_exchange_weak_explicit(volatile atomic<T>*, // freestanding typename atomic<T>::value_type*, typename atomic<T>::value_type, memory_order, memory_order) noexcept; template<class T> constexpr bool atomic_compare_exchange_weak_explicit(atomic<T>*, // freestanding typename atomic<T>::value_type*, typename atomic<T>::value_type, memory_order, memory_order) noexcept; template<class T> bool atomic_compare_exchange_strong_explicit(volatile atomic<T>*, // freestanding typename atomic<T>::value_type*, typename atomic<T>::value_type, memory_order, memory_order) noexcept; template<class T> constexpr bool atomic_compare_exchange_strong_explicit(atomic<T>*, // freestanding typename atomic<T>::value_type*, typename atomic<T>::value_type, memory_order, memory_order) noexcept; template<class T> T atomic_fetch_add(volatile atomic<T>*, // freestanding typename atomic<T>::difference_type) noexcept; template<class T> constexpr T atomic_fetch_add(atomic<T>*, typename atomic<T>::difference_type) noexcept; // freestanding template<class T> T atomic_fetch_add_explicit(volatile atomic<T>*, // freestanding typename atomic<T>::difference_type, memory_order) noexcept; template<class T> constexpr T atomic_fetch_add_explicit(atomic<T>*, typename atomic<T>::difference_type, // freestanding memory_order) noexcept; template<class T> T atomic_fetch_sub(volatile atomic<T>*, // freestanding typename atomic<T>::difference_type) noexcept; template<class T> constexpr T atomic_fetch_sub(atomic<T>*, typename atomic<T>::difference_type) noexcept; // freestanding template<class T> T atomic_fetch_sub_explicit(volatile atomic<T>*, // freestanding typename atomic<T>::difference_type, memory_order) noexcept; template<class T> constexpr T atomic_fetch_sub_explicit(atomic<T>*, typename atomic<T>::difference_type, // freestanding memory_order) noexcept; template<class T> T atomic_fetch_and(volatile atomic<T>*, // freestanding typename atomic<T>::value_type) noexcept; template<class T> constexpr T atomic_fetch_and(atomic<T>*, typename atomic<T>::value_type) noexcept; // freestanding template<class T> T atomic_fetch_and_explicit(volatile atomic<T>*, // freestanding typename atomic<T>::value_type, memory_order) noexcept; template<class T> constexpr T atomic_fetch_and_explicit(atomic<T>*, typename atomic<T>::value_type, // freestanding memory_order) noexcept; template<class T> T atomic_fetch_or(volatile atomic<T>*, // freestanding typename atomic<T>::value_type) noexcept; template<class T> constexpr T atomic_fetch_or(atomic<T>*, typename atomic<T>::value_type) noexcept; // freestanding template<class T> T atomic_fetch_or_explicit(volatile atomic<T>*, // freestanding typename atomic<T>::value_type, memory_order) noexcept; template<class T> constexpr T atomic_fetch_or_explicit(atomic<T>*, typename atomic<T>::value_type, // freestanding memory_order) noexcept; template<class T> T atomic_fetch_xor(volatile atomic<T>*, // freestanding typename atomic<T>::value_type) noexcept; template<class T> constexpr T atomic_fetch_xor(atomic<T>*, typename atomic<T>::value_type) noexcept; // freestanding template<class T> T atomic_fetch_xor_explicit(volatile atomic<T>*, // freestanding typename atomic<T>::value_type, memory_order) noexcept; template<class T> constexpr T atomic_fetch_xor_explicit(atomic<T>*, typename atomic<T>::value_type, // freestanding memory_order) noexcept; template<class T> T atomic_fetch_max(volatile atomic<T>*, // freestanding typename atomic<T>::value_type) noexcept; template<class T> constexpr T atomic_fetch_max(atomic<T>*, // freestanding typename atomic<T>::value_type) noexcept; template<class T> T atomic_fetch_max_explicit(volatile atomic<T>*, // freestanding typename atomic<T>::value_type, memory_order) noexcept; template<class T> constexpr T atomic_fetch_max_explicit(atomic<T>*, // freestanding typename atomic<T>::value_type, memory_order) noexcept; template<class T> T atomic_fetch_min(volatile atomic<T>*, // freestanding typename atomic<T>::value_type) noexcept; template<class T> constexpr T atomic_fetch_min(atomic<T>*, // freestanding typename atomic<T>::value_type) noexcept; template<class T> T atomic_fetch_min_explicit(volatile atomic<T>*, // freestanding typename atomic<T>::value_type, memory_order) noexcept; template<class T> constexpr T atomic_fetch_min_explicit(atomic<T>*, // freestanding typename atomic<T>::value_type, memory_order) noexcept; template<class T> void atomic_wait(const volatile atomic<T>*, // freestanding typename atomic<T>::value_type) noexcept; template<class T> constexpr void atomic_wait(const atomic<T>*, typename atomic<T>::value_type) noexcept; // freestanding template<class T> void atomic_wait_explicit(const volatile atomic<T>*, // freestanding typename atomic<T>::value_type, memory_order) noexcept; template<class T> constexpr void atomic_wait_explicit(const atomic<T>*, typename atomic<T>::value_type, // freestanding memory_order) noexcept; template<class T> void atomic_notify_one(volatile atomic<T>*) noexcept; // freestanding template<class T> constexpr void atomic_notify_one(atomic<T>*) noexcept; // freestanding template<class T> void atomic_notify_all(volatile atomic<T>*) noexcept; // freestanding template<class T> constexpr void atomic_notify_all(atomic<T>*) noexcept; // freestanding // [atomics.alias], type aliases using atomic_bool = atomic<bool>; // freestanding using atomic_char = atomic<char>; // freestanding using atomic_schar = atomic<signed char>; // freestanding using atomic_uchar = atomic<unsigned char>; // freestanding using atomic_short = atomic<short>; // freestanding using atomic_ushort = atomic<unsigned short>; // freestanding using atomic_int = atomic<int>; // freestanding using atomic_uint = atomic<unsigned int>; // freestanding using atomic_long = atomic<long>; // freestanding using atomic_ulong = atomic<unsigned long>; // freestanding using atomic_llong = atomic<long long>; // freestanding using atomic_ullong = atomic<unsigned long long>; // freestanding using atomic_char8_t = atomic<char8_t>; // freestanding using atomic_char16_t = atomic<char16_t>; // freestanding using atomic_char32_t = atomic<char32_t>; // freestanding using atomic_wchar_t = atomic<wchar_t>; // freestanding using atomic_int8_t = atomic<int8_t>; // freestanding using atomic_uint8_t = atomic<uint8_t>; // freestanding using atomic_int16_t = atomic<int16_t>; // freestanding using atomic_uint16_t = atomic<uint16_t>; // freestanding using atomic_int32_t = atomic<int32_t>; // freestanding using atomic_uint32_t = atomic<uint32_t>; // freestanding using atomic_int64_t = atomic<int64_t>; // freestanding using atomic_uint64_t = atomic<uint64_t>; // freestanding using atomic_int_least8_t = atomic<int_least8_t>; // freestanding using atomic_uint_least8_t = atomic<uint_least8_t>; // freestanding using atomic_int_least16_t = atomic<int_least16_t>; // freestanding using atomic_uint_least16_t = atomic<uint_least16_t>; // freestanding using atomic_int_least32_t = atomic<int_least32_t>; // freestanding using atomic_uint_least32_t = atomic<uint_least32_t>; // freestanding using atomic_int_least64_t = atomic<int_least64_t>; // freestanding using atomic_uint_least64_t = atomic<uint_least64_t>; // freestanding using atomic_int_fast8_t = atomic<int_fast8_t>; // freestanding using atomic_uint_fast8_t = atomic<uint_fast8_t>; // freestanding using atomic_int_fast16_t = atomic<int_fast16_t>; // freestanding using atomic_uint_fast16_t = atomic<uint_fast16_t>; // freestanding using atomic_int_fast32_t = atomic<int_fast32_t>; // freestanding using atomic_uint_fast32_t = atomic<uint_fast32_t>; // freestanding using atomic_int_fast64_t = atomic<int_fast64_t>; // freestanding using atomic_uint_fast64_t = atomic<uint_fast64_t>; // freestanding using atomic_intptr_t = atomic<intptr_t>; // freestanding using atomic_uintptr_t = atomic<uintptr_t>; // freestanding using atomic_size_t = atomic<size_t>; // freestanding using atomic_ptrdiff_t = atomic<ptrdiff_t>; // freestanding using atomic_intmax_t = atomic<intmax_t>; // freestanding using atomic_uintmax_t = atomic<uintmax_t>; // freestanding using atomic_signed_lock_free =

*see below*; using atomic_unsigned_lock_free =

*see below*; // [atomics.flag], flag type and operations struct atomic_flag; // freestanding bool atomic_flag_test(const volatile atomic_flag*) noexcept; // freestanding constexpr bool atomic_flag_test(const atomic_flag*) noexcept; // freestanding bool atomic_flag_test_explicit(const volatile atomic_flag*, // freestanding memory_order) noexcept; constexpr bool atomic_flag_test_explicit(const atomic_flag*, memory_order) noexcept; // freestanding bool atomic_flag_test_and_set(volatile atomic_flag*) noexcept; // freestanding constexpr bool atomic_flag_test_and_set(atomic_flag*) noexcept; // freestanding bool atomic_flag_test_and_set_explicit(volatile atomic_flag*, // freestanding memory_order) noexcept; constexpr bool atomic_flag_test_and_set_explicit(atomic_flag*, memory_order) noexcept; // freestanding void atomic_flag_clear(volatile atomic_flag*) noexcept; // freestanding constexpr void atomic_flag_clear(atomic_flag*) noexcept; // freestanding void atomic_flag_clear_explicit(volatile atomic_flag*, memory_order) noexcept; // freestanding constexpr void atomic_flag_clear_explicit(atomic_flag*, memory_order) noexcept; // freestanding void atomic_flag_wait(const volatile atomic_flag*, bool) noexcept; // freestanding constexpr void atomic_flag_wait(const atomic_flag*, bool) noexcept; // freestanding void atomic_flag_wait_explicit(const volatile atomic_flag*, // freestanding bool, memory_order) noexcept; constexpr void atomic_flag_wait_explicit(const atomic_flag*, // freestanding bool, memory_order) noexcept; void atomic_flag_notify_one(volatile atomic_flag*) noexcept; // freestanding constexpr void atomic_flag_notify_one(atomic_flag*) noexcept; // freestanding void atomic_flag_notify_all(volatile atomic_flag*) noexcept; // freestanding constexpr void atomic_flag_notify_all(atomic_flag*) noexcept; // freestanding #define ATOMIC_FLAG_INIT

*see below*// freestanding // [atomics.fences], fences extern "C" constexpr void atomic_thread_fence(memory_order) noexcept; // freestanding extern "C" constexpr void atomic_signal_fence(memory_order) noexcept; // freestanding }

### 33.5.3 Type aliases [atomics.alias]

### 33.5.4 Order and consistency [atomics.order]

*unspecified*{ relaxed, consume, acquire, release, acq_rel, seq_cst }; }

- memory_order::relaxed: no operation orders memory.
- memory_order::release, memory_order::acq_rel, and memory_order::seq_cst: a store operation performs a release operation on the affected memory location.
- memory_order::consume: a load operation performs a consume operation on the affected memory location.
- memory_order::acquire, memory_order::acq_rel, and memory_order::seq_cst: a load operation performs an acquire operation on the affected memory location.

*coherence-ordered before*another atomic operation B on M if

- A is a modification, and B reads the value stored by A, or
- A precedes B in the modification order of M, or
- A and B are not the same atomic read-modify-write operation, and there exists an atomic modification X of M such that A reads the value stored by X and X precedes B in the modification order of M, or
- there exists an atomic modification X of M such that A is coherence-ordered before X and X is coherence-ordered before B.

- if A and B are both memory_order::seq_cst operations, then A precedes B in S; and
- if A is a memory_order::seq_cst operation and B happens before a memory_order::seq_cst fence Y, then A precedes Y in S; and
- if a memory_order::seq_cst fence X happens before A and B is a memory_order::seq_cst operation, then X precedes B in S; and
- if a memory_order::seq_cst fence X happens before A and B happens before a memory_order::seq_cst fence Y, then X precedes Y in S.

*Note 5*:

*end note*]

*Note 6*:

*end note*]

*Note 7*:

*end note*]

*Recommended practice*: The implementation should make atomic stores visible to atomic loads, and atomic loads should observe atomic stores, within a reasonable amount of time.

```
template<class T>
constexpr T kill_dependency(T y) noexcept;
```

### 33.5.5 Lock-free property [atomics.lockfree]

*unspecified*#define ATOMIC_CHAR_LOCK_FREE

*unspecified*#define ATOMIC_CHAR8_T_LOCK_FREE

*unspecified*#define ATOMIC_CHAR16_T_LOCK_FREE

*unspecified*#define ATOMIC_CHAR32_T_LOCK_FREE

*unspecified*#define ATOMIC_WCHAR_T_LOCK_FREE

*unspecified*#define ATOMIC_SHORT_LOCK_FREE

*unspecified*#define ATOMIC_INT_LOCK_FREE

*unspecified*#define ATOMIC_LONG_LOCK_FREE

*unspecified*#define ATOMIC_LLONG_LOCK_FREE

*unspecified*#define ATOMIC_POINTER_LOCK_FREE

*unspecified*

### 33.5.6 Waiting and notifying [atomics.wait]

*Atomic waiting operations*and

*atomic notifying operations*provide a mechanism to wait for the value of an atomic object to change more efficiently than can be achieved with polling.

*Note 3*:

- atomic<T>::notify_one and atomic<T>::notify_all,
- atomic_flag::notify_one and atomic_flag::notify_all,
- atomic_notify_one and atomic_notify_all,
- atomic_flag_notify_one and atomic_flag_notify_all, and
- atomic_ref<T>::notify_one and atomic_ref<T>::notify_all.

*end note*]

*eligible to be unblocked*by a call to an atomic notifying operation on M if there exist side effects X and Y on M such that:

- the atomic waiting operation has blocked after observing the result of X,
- X precedes Y in the modification order of M, and
- Y happens before the call to the atomic notifying operation.

### 33.5.7 Class template atomic_ref [atomics.ref.generic]

#### 33.5.7.1 General [atomics.ref.generic.general]

*exposition only*public: using value_type = 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(T, memory_order = memory_order::seq_cst) const noexcept; constexpr T operator=(T) const noexcept; constexpr T load(memory_order = memory_order::seq_cst) const noexcept; constexpr operator T() const noexcept; constexpr T exchange(T, memory_order = memory_order::seq_cst) const noexcept; constexpr bool compare_exchange_weak(T&, T, memory_order, memory_order) const noexcept; constexpr bool compare_exchange_strong(T&, T, memory_order, memory_order) const noexcept; constexpr bool compare_exchange_weak(T&, T, memory_order = memory_order::seq_cst) const noexcept; constexpr bool compare_exchange_strong(T&, T, memory_order = memory_order::seq_cst) const noexcept; constexpr void wait(T, memory_order = memory_order::seq_cst) const noexcept; constexpr void notify_one() const noexcept; constexpr void notify_all() const noexcept; }; }

#### 33.5.7.2 Operations [atomics.ref.ops]

```
static constexpr size_t required_alignment;
```

*Note 1*:

*end note*]

```
static constexpr bool is_always_lock_free;
```

```
bool is_lock_free() const noexcept;
```

```
constexpr atomic_ref(T& obj);
```

```
constexpr atomic_ref(const atomic_ref& ref) noexcept;
```

```
constexpr void store(T desired, memory_order order = memory_order::seq_cst) const noexcept;
```

```
constexpr T operator=(T desired) const noexcept;
```

```
constexpr T load(memory_order order = memory_order::seq_cst) const noexcept;
```

```
constexpr operator T() const noexcept;
```

```
constexpr T exchange(T desired, memory_order order = memory_order::seq_cst) const noexcept;
```

```
constexpr bool compare_exchange_weak(T& expected, T desired,
memory_order success, memory_order failure) const noexcept;
constexpr bool compare_exchange_strong(T& expected, T desired,
memory_order success, memory_order failure) const noexcept;
constexpr bool compare_exchange_weak(T& expected, T desired,
memory_order order = memory_order::seq_cst) const noexcept;
constexpr bool compare_exchange_strong(T& expected, T desired,
memory_order order = memory_order::seq_cst) const noexcept;
```

*Remarks*: A weak compare-and-exchange operation may fail spuriously.

*Note 2*:

*end note*]

```
constexpr void wait(T old, memory_order order = memory_order::seq_cst) const noexcept;
```

```
constexpr void notify_one() const noexcept;
```

*Effects*: Unblocks the execution of at least one atomic waiting operation on *ptr that is eligible to be unblocked ([atomics.wait]) by this call, if any such atomic waiting operations exist.

```
constexpr void notify_all() const noexcept;
```

*Effects*: Unblocks the execution of all atomic waiting operations on *ptr that are eligible to be unblocked ([atomics.wait]) by this call.

#### 33.5.7.3 Specializations for integral types [atomics.ref.int]

*integral-type*, the specialization atomic_ref<

*integral-type*> provides additional atomic operations appropriate to integral types.

*Note 1*: —

*end note*]

*integral-type*> { private:

*integral-type** ptr; //

*exposition only*public: using value_type =

*integral-type*; using difference_type = value_type; 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(

*integral-type*&); constexpr atomic_ref(const atomic_ref&) noexcept; atomic_ref& operator=(const atomic_ref&) = delete; constexpr void store(

*integral-type*, memory_order = memory_order::seq_cst) const noexcept; constexpr

*integral-type*operator=(

*integral-type*) const noexcept; constexpr

*integral-type*load(memory_order = memory_order::seq_cst) const noexcept; constexpr operator

*integral-type*() const noexcept; constexpr

*integral-type*exchange(

*integral-type*, memory_order = memory_order::seq_cst) const noexcept; constexpr bool compare_exchange_weak(

*integral-type*&,

*integral-type*, memory_order, memory_order) const noexcept; constexpr bool compare_exchange_strong(

*integral-type*&,

*integral-type*, memory_order, memory_order) const noexcept; constexpr bool compare_exchange_weak(

*integral-type*&,

*integral-type*, memory_order = memory_order::seq_cst) const noexcept; constexpr bool compare_exchange_strong(

*integral-type*&,

*integral-type*, memory_order = memory_order::seq_cst) const noexcept; constexpr

*integral-type*fetch_add(

*integral-type*, memory_order = memory_order::seq_cst) const noexcept; constexpr

*integral-type*fetch_sub(

*integral-type*, memory_order = memory_order::seq_cst) const noexcept; constexpr

*integral-type*fetch_and(

*integral-type*, memory_order = memory_order::seq_cst) const noexcept; constexpr

*integral-type*fetch_or(

*integral-type*, memory_order = memory_order::seq_cst) const noexcept; constexpr

*integral-type*fetch_xor(

*integral-type*, memory_order = memory_order::seq_cst) const noexcept; constexpr

*integral-type*fetch_max(

*integral-type*, memory_order = memory_order::seq_cst) const noexcept; constexpr

*integral-type*fetch_min(

*integral-type*, memory_order = memory_order::seq_cst) const noexcept; constexpr

*integral-type*operator++(int) const noexcept; constexpr

*integral-type*operator--(int) const noexcept; constexpr

*integral-type*operator++() const noexcept; constexpr

*integral-type*operator--() const noexcept; constexpr

*integral-type*operator+=(

*integral-type*) const noexcept; constexpr

*integral-type*operator-=(

*integral-type*) const noexcept; constexpr

*integral-type*operator&=(

*integral-type*) const noexcept; constexpr

*integral-type*operator|=(

*integral-type*) const noexcept; constexpr

*integral-type*operator^=(

*integral-type*) const noexcept; constexpr void wait(

*integral-type*, memory_order = memory_order::seq_cst) const noexcept; constexpr void notify_one() const noexcept; constexpr void notify_all() const noexcept; }; }

`constexpr `*integral-type* fetch_*key*(*integral-type* operand,
memory_order order = memory_order::seq_cst) const noexcept;

*Effects*: Atomically replaces the value referenced by *ptr with the result of the computation applied to the value referenced by *ptr and the given operand.

*Remarks*: Except for fetch_max and fetch_min, for signed integer types the result is as if the object value and parameters were converted to their corresponding unsigned types, the computation performed on those types, and the result converted back to the signed type.

`constexpr `*integral-type* operator *op*=(*integral-type* operand) const noexcept;

#### 33.5.7.4 Specializations for floating-point types [atomics.ref.float]

*floating-point-type*, the specialization atomic_ref<

*floating-point*> provides additional atomic operations appropriate to floating-point types.

*floating-point-type*> { private:

*floating-point-type** ptr; //

*exposition only*public: using value_type =

*floating-point-type*; using difference_type = value_type; 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(

*floating-point-type*&); constexpr atomic_ref(const atomic_ref&) noexcept; atomic_ref& operator=(const atomic_ref&) = delete; constexpr void store(

*floating-point-type*, memory_order = memory_order::seq_cst) const noexcept; constexpr

*floating-point-type*operator=(

*floating-point-type*) const noexcept; constexpr

*floating-point-type*load(memory_order = memory_order::seq_cst) const noexcept; constexpr operator

*floating-point-type*() const noexcept; constexpr

*floating-point-type*exchange(

*floating-point-type*, memory_order = memory_order::seq_cst) const noexcept; constexpr bool compare_exchange_weak(

*floating-point-type*&,

*floating-point-type*, memory_order, memory_order) const noexcept; constexpr bool compare_exchange_strong(

*floating-point-type*&,

*floating-point-type*, memory_order, memory_order) const noexcept; constexpr bool compare_exchange_weak(

*floating-point-type*&,

*floating-point-type*, memory_order = memory_order::seq_cst) const noexcept; constexpr bool compare_exchange_strong(

*floating-point-type*&,

*floating-point-type*, memory_order = memory_order::seq_cst) const noexcept; constexpr

*floating-point-type*fetch_add(

*floating-point-type*, memory_order = memory_order::seq_cst) const noexcept; constexpr

*floating-point-type*fetch_sub(

*floating-point-type*, memory_order = memory_order::seq_cst) const noexcept; constexpr

*floating-point-type*operator+=(

*floating-point-type*) const noexcept; constexpr

*floating-point-type*operator-=(

*floating-point-type*) const noexcept; constexpr void wait(

*floating-point-type*, memory_order = memory_order::seq_cst) const noexcept; constexpr void notify_one() const noexcept; constexpr void notify_all() const noexcept; }; }

`constexpr `*floating-point-type* fetch_*key*(*floating-point-type* operand,
memory_order order = memory_order::seq_cst) const noexcept;

*Effects*: Atomically replaces the value referenced by *ptr with the result of the computation applied to the value referenced by *ptr and the given operand.

*Remarks*: If the result is not a representable value for its type ([expr.pre]), the result is unspecified, but the operations otherwise have no undefined behavior.

*floating-point-type*should conform to the std::numeric_limits<

*floating-point-type*> traits associated with the floating-point type ([limits.syn]).

`constexpr `*floating-point-type* operator *op*=(*floating-point-type* operand) const noexcept;

#### 33.5.7.5 Partial specialization for pointers [atomics.ref.pointer]

*exposition only*public: using value_type = T*; using difference_type = ptrdiff_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(T*, memory_order = memory_order::seq_cst) const noexcept; constexpr T* operator=(T*) const noexcept; constexpr T* load(memory_order = memory_order::seq_cst) const noexcept; constexpr operator T*() const noexcept; constexpr T* exchange(T*, memory_order = memory_order::seq_cst) const noexcept; constexpr bool compare_exchange_weak(T*&, T*, memory_order, memory_order) const noexcept; constexpr bool compare_exchange_strong(T*&, T*, memory_order, memory_order) const noexcept; constexpr bool compare_exchange_weak(T*&, T*, memory_order = memory_order::seq_cst) const noexcept; constexpr bool compare_exchange_strong(T*&, T*, memory_order = memory_order::seq_cst) const noexcept; constexpr T* fetch_add(difference_type, memory_order = memory_order::seq_cst) const noexcept; constexpr T* fetch_sub(difference_type, memory_order = memory_order::seq_cst) const noexcept; constexpr T* fetch_max(T*, memory_order = memory_order::seq_cst) const noexcept; constexpr T* fetch_min(T*, memory_order = memory_order::seq_cst) const noexcept; constexpr T* operator++(int) const noexcept; constexpr T* operator--(int) const noexcept; constexpr T* operator++() const noexcept; constexpr T* operator--() const noexcept; constexpr T* operator+=(difference_type) const noexcept; constexpr T* operator-=(difference_type) const noexcept; constexpr void wait(T*, memory_order = memory_order::seq_cst) const noexcept; constexpr void notify_one() const noexcept; constexpr void notify_all() const noexcept; }; }

`constexpr T* fetch_`*key*(difference_type operand, memory_order order = memory_order::seq_cst) const noexcept;

*Effects*: Atomically replaces the value referenced by *ptr with the result of the computation applied to the value referenced by *ptr and the given operand.

*Note 1*:

*end note*]

`constexpr T* operator `*op*=(difference_type operand) const noexcept;

#### 33.5.7.6 Member operators common to integers and pointers to objects [atomics.ref.memop]

```
constexpr value_type operator++(int) const noexcept;
```

```
constexpr value_type operator--(int) const noexcept;
```

```
constexpr value_type operator++() const noexcept;
```

```
constexpr value_type operator--() const noexcept;
```

### 33.5.8 Class template atomic [atomics.types.generic]

#### 33.5.8.1 General [atomics.types.generic.general]

*implementation-defined*; bool is_lock_free() const volatile noexcept; bool is_lock_free() const noexcept; // [atomics.types.operations], operations on atomic types constexpr atomic() noexcept(is_nothrow_default_constructible_v<T>); constexpr atomic(T) noexcept; atomic(const atomic&) = delete; atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; T load(memory_order = memory_order::seq_cst) const volatile noexcept; constexpr T load(memory_order = memory_order::seq_cst) const noexcept; operator T() const volatile noexcept; constexpr operator T() const noexcept; void store(T, memory_order = memory_order::seq_cst) volatile noexcept; constexpr void store(T, memory_order = memory_order::seq_cst) noexcept; T operator=(T) volatile noexcept; constexpr T operator=(T) noexcept; T exchange(T, memory_order = memory_order::seq_cst) volatile noexcept; constexpr T exchange(T, memory_order = memory_order::seq_cst) noexcept; bool compare_exchange_weak(T&, T, memory_order, memory_order) volatile noexcept; constexpr bool compare_exchange_weak(T&, T, memory_order, memory_order) noexcept; bool compare_exchange_strong(T&, T, memory_order, memory_order) volatile noexcept; constexpr bool compare_exchange_strong(T&, T, memory_order, memory_order) noexcept; bool compare_exchange_weak(T&, T, memory_order = memory_order::seq_cst) volatile noexcept; constexpr bool compare_exchange_weak(T&, T, memory_order = memory_order::seq_cst) noexcept; bool compare_exchange_strong(T&, T, memory_order = memory_order::seq_cst) volatile noexcept; constexpr bool compare_exchange_strong(T&, T, memory_order = memory_order::seq_cst) noexcept; void wait(T, memory_order = memory_order::seq_cst) const volatile noexcept; constexpr void wait(T, memory_order = memory_order::seq_cst) const noexcept; void notify_one() volatile noexcept; constexpr void notify_one() noexcept; void notify_all() volatile noexcept; constexpr void notify_all() noexcept; }; }

#### 33.5.8.2 Operations on atomic types [atomics.types.operations]

```
constexpr atomic() noexcept(is_nothrow_default_constructible_v<T>);
```

```
constexpr atomic(T desired) noexcept;
```

*Note 1*:

*end note*]

```
void store(T desired, memory_order order = memory_order::seq_cst) volatile noexcept;
constexpr void store(T desired, memory_order order = memory_order::seq_cst) noexcept;
```

```
T operator=(T desired) volatile noexcept;
constexpr T operator=(T desired) noexcept;
```

```
T load(memory_order order = memory_order::seq_cst) const volatile noexcept;
constexpr T load(memory_order order = memory_order::seq_cst) const noexcept;
```

```
operator T() const volatile noexcept;
constexpr operator T() const noexcept;
```

```
T exchange(T desired, memory_order order = memory_order::seq_cst) volatile noexcept;
constexpr T exchange(T desired, memory_order order = memory_order::seq_cst) noexcept;
```

```
bool compare_exchange_weak(T& expected, T desired,
memory_order success, memory_order failure) volatile noexcept;
constexpr bool compare_exchange_weak(T& expected, T desired,
memory_order success, memory_order failure) noexcept;
bool compare_exchange_strong(T& expected, T desired,
memory_order success, memory_order failure) volatile noexcept;
constexpr bool compare_exchange_strong(T& expected, T desired,
memory_order success, memory_order failure) noexcept;
bool compare_exchange_weak(T& expected, T desired,
memory_order order = memory_order::seq_cst) volatile noexcept;
constexpr bool compare_exchange_weak(T& expected, T desired,
memory_order order = memory_order::seq_cst) noexcept;
bool compare_exchange_strong(T& expected, T desired,
memory_order order = memory_order::seq_cst) volatile noexcept;
constexpr bool compare_exchange_strong(T& expected, T desired,
memory_order order = memory_order::seq_cst) noexcept;
```

*Note 4*:

*end note*]

*Example 1*:

*end example*]

*Example 2*:

*end example*]

*Remarks*: A weak compare-and-exchange operation may fail spuriously.

*Note 5*:

*end note*]

*Note 6*:

*end note*]

*Note 7*:

*end note*]

*Note 8*:

*end note*]

```
void wait(T old, memory_order order = memory_order::seq_cst) const volatile noexcept;
constexpr void wait(T old, memory_order order = memory_order::seq_cst) const noexcept;
```

```
void notify_one() volatile noexcept;
constexpr void notify_one() noexcept;
```

*Effects*: Unblocks the execution of at least one atomic waiting operation that is eligible to be unblocked ([atomics.wait]) by this call, if any such atomic waiting operations exist.

```
void notify_all() volatile noexcept;
constexpr void notify_all() noexcept;
```

*Effects*: Unblocks the execution of all atomic waiting operations that are eligible to be unblocked ([atomics.wait]) by this call.

#### 33.5.8.3 Specializations for integers [atomics.types.int]

*integral-type*, the specialization atomic<

*integral-type*> provides additional atomic operations appropriate to integral types.

*Note 1*: —

*end note*]

*integral-type*> { using value_type =

*integral-type*; using difference_type = value_type; static constexpr bool is_always_lock_free =

*implementation-defined*; bool is_lock_free() const volatile noexcept; bool () const noexcept; constexpr atomic() noexcept; constexpr atomic(

*integral-type*) noexcept; atomic(const atomic&) = delete; atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; void store(

*integral-type*, memory_order = memory_order::seq_cst) volatile noexcept; constexpr void store(

*integral-type*, memory_order = memory_order::seq_cst) noexcept;

*integral-type*operator=(

*integral-type*) volatile noexcept; constexpr

*integral-type*operator=(

*integral-type*) noexcept;

*integral-type*load(memory_order = memory_order::seq_cst) const volatile noexcept; constexpr

*integral-type*load(memory_order = memory_order::seq_cst) const noexcept; operator

*integral-type*() const volatile noexcept; constexpr operator

*integral-type*() const noexcept;

*integral-type*exchange(

*integral-type*, memory_order = memory_order::seq_cst) volatile noexcept; constexpr

*integral-type*exchange(

*integral-type*, memory_order = memory_order::seq_cst) noexcept; bool compare_exchange_weak(

*integral-type*&,

*integral-type*, memory_order, memory_order) volatile noexcept; constexpr bool compare_exchange_weak(

*integral-type*&,

*integral-type*, memory_order, memory_order) noexcept; bool compare_exchange_strong(

*integral-type*&,

*integral-type*, memory_order, memory_order) volatile noexcept; constexpr bool compare_exchange_strong(

*integral-type*&,

*integral-type*, memory_order, memory_order) noexcept; bool compare_exchange_weak(

*integral-type*&,

*integral-type*, memory_order = memory_order::seq_cst) volatile noexcept; constexpr bool compare_exchange_weak(

*integral-type*&,

*integral-type*, memory_order = memory_order::seq_cst) noexcept; bool compare_exchange_strong(

*integral-type*&,

*integral-type*, memory_order = memory_order::seq_cst) volatile noexcept; constexpr bool compare_exchange_strong(

*integral-type*&,

*integral-type*, memory_order = memory_order::seq_cst) noexcept;

*integral-type*fetch_add(

*integral-type*, memory_order = memory_order::seq_cst) volatile noexcept; constexpr

*integral-type*fetch_add(

*integral-type*, memory_order = memory_order::seq_cst) noexcept;

*integral-type*fetch_sub(

*integral-type*, memory_order = memory_order::seq_cst) volatile noexcept; constexpr

*integral-type*fetch_sub(

*integral-type*, memory_order = memory_order::seq_cst) noexcept;

*integral-type*fetch_and(

*integral-type*, memory_order = memory_order::seq_cst) volatile noexcept; constexpr

*integral-type*fetch_and(

*integral-type*, memory_order = memory_order::seq_cst) noexcept;

*integral-type*fetch_or(

*integral-type*, memory_order = memory_order::seq_cst) volatile noexcept; constexpr

*integral-type*fetch_or(

*integral-type*, memory_order = memory_order::seq_cst) noexcept;

*integral-type*fetch_xor(

*integral-type*, memory_order = memory_order::seq_cst) volatile noexcept; constexpr

*integral-type*fetch_xor(

*integral-type*, memory_order = memory_order::seq_cst) noexcept;

*integral-type*fetch_max(

*integral-type*, memory_order = memory_order::seq_cst) volatile noexcept; constexpr

*integral-type*fetch_max(

*integral-type*, memory_order = memory_order::seq_cst) noexcept;

*integral-type*fetch_min(

*integral-type*, memory_order = memory_order::seq_cst) volatile noexcept; constexpr

*integral-type*fetch_min(

*integral-type*, memory_order = memory_order::seq_cst) noexcept;

*integral-type*operator++(int) volatile noexcept; constexpr

*integral-type*operator++(int) noexcept;

*integral-type*operator--(int) volatile noexcept; constexpr

*integral-type*operator--(int) noexcept;

*integral-type*operator++() volatile noexcept; constexpr

*integral-type*operator++() noexcept;

*integral-type*operator--() volatile noexcept; constexpr

*integral-type*operator--() noexcept;

*integral-type*operator+=(

*integral-type*) volatile noexcept; constexpr

*integral-type*operator+=(

*integral-type*) noexcept;

*integral-type*operator-=(

*integral-type*) volatile noexcept; constexpr

*integral-type*operator-=(

*integral-type*) noexcept;

*integral-type*operator&=(

*integral-type*) volatile noexcept; constexpr

*integral-type*operator&=(

*integral-type*) noexcept;

*integral-type*operator|=(

*integral-type*) volatile noexcept; constexpr

*integral-type*operator|=(

*integral-type*) noexcept;

*integral-type*operator^=(

*integral-type*) volatile noexcept; constexpr

*integral-type*operator^=(

*integral-type*) noexcept; void wait(

*integral-type*, memory_order = memory_order::seq_cst) const volatile noexcept; constexpr void wait(

*integral-type*, memory_order = memory_order::seq_cst) const noexcept; void notify_one() volatile noexcept; constexpr void notify_one() noexcept; void notify_all() volatile noexcept; constexpr void notify_all() noexcept; }; }

`T fetch_`*key*(T operand, memory_order order = memory_order::seq_cst) volatile noexcept;
constexpr T fetch_*key*(T operand, memory_order order = memory_order::seq_cst) noexcept;

*Effects*: Atomically replaces the value pointed to by this with the result of the computation applied to the value pointed to by this and the given operand.

*Remarks*: Except for fetch_max and fetch_min, for signed integer types the result is as if the object value and parameters were converted to their corresponding unsigned types, the computation performed on those types, and the result converted back to the signed type.

`T operator `*op*=(T operand) volatile noexcept;
constexpr T operator *op*=(T operand) noexcept;

#### 33.5.8.4 Specializations for floating-point types [atomics.types.float]

*floating-point-type*, the specialization atomic<

*floating-point-type*> provides additional atomic operations appropriate to floating-point types.

*floating-point-type*> { using value_type =

*floating-point-type*; using difference_type = value_type; static constexpr bool is_always_lock_free =

*implementation-defined*; bool is_lock_free() const volatile noexcept; bool is_lock_free() const noexcept; constexpr atomic() noexcept; constexpr atomic(

*floating-point-type*) noexcept; atomic(const atomic&) = delete; atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; void store(

*floating-point-type*, memory_order = memory_order::seq_cst) volatile noexcept; constexpr void store(

*floating-point-type*, memory_order = memory_order::seq_cst) noexcept;

*floating-point-type*operator=(

*floating-point-type*) volatile noexcept; constexpr

*floating-point-type*operator=(

*floating-point-type*) noexcept;

*floating-point-type*load(memory_order = memory_order::seq_cst) volatile noexcept; constexpr

*floating-point-type*load(memory_order = memory_order::seq_cst) noexcept; operator

*floating-point-type*() volatile noexcept; constexpr operator

*floating-point-type*() noexcept;

*floating-point-type*exchange(

*floating-point-type*, memory_order = memory_order::seq_cst) volatile noexcept; constexpr

*floating-point-type*exchange(

*floating-point-type*, memory_order = memory_order::seq_cst) noexcept; bool compare_exchange_weak(

*floating-point-type*&,

*floating-point-type*, memory_order, memory_order) volatile noexcept; constexpr bool compare_exchange_weak(

*floating-point-type*&,

*floating-point-type*, memory_order, memory_order) noexcept; bool compare_exchange_strong(

*floating-point-type*&,

*floating-point-type*, memory_order, memory_order) volatile noexcept; constexpr bool compare_exchange_strong(

*floating-point-type*&,

*floating-point-type*, memory_order, memory_order) noexcept; bool compare_exchange_weak(

*floating-point-type*&,

*floating-point-type*, memory_order = memory_order::seq_cst) volatile noexcept; constexpr bool compare_exchange_weak(

*floating-point-type*&,

*floating-point-type*, memory_order = memory_order::seq_cst) noexcept; bool compare_exchange_strong(

*floating-point-type*&,

*floating-point-type*, memory_order = memory_order::seq_cst) volatile noexcept; constexpr bool compare_exchange_strong(

*floating-point-type*&,

*floating-point-type*, memory_order = memory_order::seq_cst) noexcept;

*floating-point-type*fetch_add(

*floating-point-type*, memory_order = memory_order::seq_cst) volatile noexcept; constexpr

*floating-point-type*fetch_add(

*floating-point-type*, memory_order = memory_order::seq_cst) noexcept;

*floating-point-type*fetch_sub(

*floating-point-type*, memory_order = memory_order::seq_cst) volatile noexcept; constexpr

*floating-point-type*fetch_sub(

*floating-point-type*, memory_order = memory_order::seq_cst) noexcept;

*floating-point-type*operator+=(

*floating-point-type*) volatile noexcept; constexpr

*floating-point-type*operator+=(

*floating-point-type*) noexcept;

*floating-point-type*operator-=(

*floating-point-type*) volatile noexcept; constexpr

*floating-point-type*operator-=(

*floating-point-type*) noexcept; void wait(

*floating-point-type*, memory_order = memory_order::seq_cst) const volatile noexcept; constexpr void wait(

*floating-point-type*, memory_order = memory_order::seq_cst) const noexcept; void notify_one() volatile noexcept; constexpr void notify_one() noexcept; void notify_all() volatile noexcept; constexpr void notify_all() noexcept; }; }

`T fetch_`*key*(T operand, memory_order order = memory_order::seq_cst) volatile noexcept;
constexpr T fetch_*key*(T operand, memory_order order = memory_order::seq_cst) noexcept;

*Effects*: Atomically replaces the value pointed to by this with the result of the computation applied to the value pointed to by this and the given operand.

*Remarks*: If the result is not a representable value for its type ([expr.pre]) the result is unspecified, but the operations otherwise have no undefined behavior.

*floating-point-type*should conform to the std::numeric_limits<

*floating-point-type*> traits associated with the floating-point type ([limits.syn]).

`T operator `*op*=(T operand) volatile noexcept;
constexpr T operator *op*=(T operand) noexcept;

*Remarks*: If the result is not a representable value for its type ([expr.pre]) the result is unspecified, but the operations otherwise have no undefined behavior.

*floating-point-type*should conform to the std::numeric_limits<

*floating-point-type*> traits associated with the floating-point type ([limits.syn]).

#### 33.5.8.5 Partial specialization for pointers [atomics.types.pointer]

*implementation-defined*; bool is_lock_free() const volatile noexcept; bool is_lock_free() const noexcept; constexpr atomic() noexcept; constexpr atomic(T*) noexcept; atomic(const atomic&) = delete; atomic& operator=(const atomic&) = delete; atomic& operator=(const atomic&) volatile = delete; void store(T*, memory_order = memory_order::seq_cst) volatile noexcept; constexpr void store(T*, memory_order = memory_order::seq_cst) noexcept; T* operator=(T*) volatile noexcept; constexpr T* operator=(T*) noexcept; T* load(memory_order = memory_order::seq_cst) const volatile noexcept; constexpr T* load(memory_order = memory_order::seq_cst) const noexcept; operator T*() const volatile noexcept; constexpr operator T*() const noexcept; T* exchange(T*, memory_order = memory_order::seq_cst) volatile noexcept; constexpr T* exchange(T*, memory_order = memory_order::seq_cst) noexcept; bool compare_exchange_weak(T*&, T*, memory_order, memory_order) volatile noexcept; constexpr bool compare_exchange_weak(T*&, T*, memory_order, memory_order) noexcept; bool compare_exchange_strong(T*&, T*, memory_order, memory_order) volatile noexcept; constexpr bool compare_exchange_strong(T*&, T*, memory_order, memory_order) noexcept; bool compare_exchange_weak(T*&, T*, memory_order = memory_order::seq_cst) volatile noexcept; constexpr bool compare_exchange_weak(T*&, T*, memory_order = memory_order::seq_cst) noexcept; bool compare_exchange_strong(T*&, T*, memory_order = memory_order::seq_cst) volatile noexcept; constexpr bool compare_exchange_strong(T*&, T*, memory_order = memory_order::seq_cst) noexcept; T* fetch_add(ptrdiff_t, memory_order = memory_order::seq_cst) volatile noexcept; constexpr T* fetch_add(ptrdiff_t, memory_order = memory_order::seq_cst) noexcept; T* fetch_sub(ptrdiff_t, memory_order = memory_order::seq_cst) volatile noexcept; constexpr T* fetch_sub(ptrdiff_t, memory_order = memory_order::seq_cst) noexcept; T* fetch_max(T*, memory_order = memory_order::seq_cst) volatile noexcept; constexpr T* fetch_max(T*, memory_order = memory_order::seq_cst) noexcept; T* fetch_min(T*, memory_order = memory_order::seq_cst) volatile noexcept; constexpr T* fetch_min(T*, memory_order = memory_order::seq_cst) noexcept; T* operator++(int) volatile noexcept; constexpr T* operator++(int) noexcept; T* operator--(int) volatile noexcept; constexpr T* operator--(int) noexcept; T* operator++() volatile noexcept; constexpr T* operator++() noexcept; T* operator--() volatile noexcept; constexpr T* operator--() noexcept; T* operator+=(ptrdiff_t) volatile noexcept; constexpr T* operator+=(ptrdiff_t) noexcept; T* operator-=(ptrdiff_t) volatile noexcept; constexpr T* operator-=(ptrdiff_t) noexcept; void wait(T*, memory_order = memory_order::seq_cst) const volatile noexcept; constexpr void wait(T*, memory_order = memory_order::seq_cst) const noexcept; void notify_one() volatile noexcept; constexpr void notify_one() noexcept; void notify_all() volatile noexcept; constexpr void notify_all() noexcept; }; }

key | Op | Computation | key | Op | Computation | |

add | + | addition | sub | - | subtraction | |

max | maximum | min | minimum |

`T* fetch_`*key*(ptrdiff_t operand, memory_order order = memory_order::seq_cst) volatile noexcept;
constexpr T* fetch_*key*(ptrdiff_t operand, memory_order order = memory_order::seq_cst) noexcept;

*Effects*: Atomically replaces the value pointed to by this with the result of the computation applied to the value pointed to by this and the given operand.

*Note 2*:

*end note*]

`T* operator `*op*=(ptrdiff_t operand) volatile noexcept;
constexpr T* operator *op*=(ptrdiff_t operand) noexcept;

#### 33.5.8.6 Member operators common to integers and pointers to objects [atomics.types.memop]

```
value_type operator++(int) volatile noexcept;
constexpr value_type operator++(int) noexcept;
```

```
value_type operator--(int) volatile noexcept;
constexpr value_type operator--(int) noexcept;
```

```
value_type operator++() volatile noexcept;
constexpr value_type operator++() noexcept;
```

```
value_type operator--() volatile noexcept;
constexpr value_type operator--() noexcept;
```

#### 33.5.8.7 Partial specializations for smart pointers [util.smartptr.atomic]

#### 33.5.8.7.1 General [util.smartptr.atomic.general]

*Example 1*: template<typename T> class atomic_list { struct node { T t; shared_ptr<node> next; }; atomic<shared_ptr<node>> head; public: shared_ptr<node> find(T t) const { auto p = head.load(); while (p && p->t != t) p = p->next; return p; } void push_front(T t) { auto p = make_shared<node>(); p->t = t; p->next = head; while (!head.compare_exchange_weak(p->next, p)) {} } }; —

*end example*]

#### 33.5.8.7.3 Partial specialization for weak_ptr [util.smartptr.atomic.weak]

*implementation-defined*; bool is_lock_free() const noexcept; constexpr atomic() noexcept; constexpr atomic(weak_ptr<T> desired) noexcept; atomic(const atomic&) = delete; constexpr void operator=(const atomic&) = delete; constexpr weak_ptr<T> load(memory_order order = memory_order::seq_cst) const noexcept; constexpr operator weak_ptr<T>() const noexcept; constexpr void store(weak_ptr<T> desired, memory_order order = memory_order::seq_cst) noexcept; constexpr void operator=(weak_ptr<T> desired) noexcept; constexpr weak_ptr<T> exchange(weak_ptr<T> desired, memory_order order = memory_order::seq_cst) noexcept; constexpr bool compare_exchange_weak(weak_ptr<T>& expected, weak_ptr<T> desired, memory_order success, memory_order failure) noexcept; constexpr bool compare_exchange_strong(weak_ptr<T>& expected, weak_ptr<T> desired, memory_order success, memory_order failure) noexcept; constexpr bool compare_exchange_weak(weak_ptr<T>& expected, weak_ptr<T> desired, memory_order order = memory_order::seq_cst) noexcept; constexpr bool compare_exchange_strong(weak_ptr<T>& expected, weak_ptr<T> desired, memory_order order = memory_order::seq_cst) noexcept; constexpr void wait(weak_ptr<T> old, memory_order order = memory_order::seq_cst) const noexcept; constexpr void notify_one() noexcept; constexpr void notify_all() noexcept; private: weak_ptr<T> p; //

*exposition only*}; }

```
constexpr atomic() noexcept;
```

```
constexpr atomic(weak_ptr<T> desired) noexcept;
```

*Note 1*:

*end note*]

```
constexpr void store(weak_ptr<T> desired, memory_order order = memory_order::seq_cst) noexcept;
```

```
constexpr void operator=(weak_ptr<T> desired) noexcept;
```

```
constexpr weak_ptr<T> load(memory_order order = memory_order::seq_cst) const noexcept;
```

```
constexpr operator weak_ptr<T>() const noexcept;
```

```
constexpr weak_ptr<T> exchange(weak_ptr<T> desired, memory_order order = memory_order::seq_cst) noexcept;
```

```
constexpr bool compare_exchange_weak(weak_ptr<T>& expected, weak_ptr<T> desired,
memory_order success, memory_order failure) noexcept;
constexpr bool compare_exchange_strong(weak_ptr<T>& expected, weak_ptr<T> desired,
memory_order success, memory_order failure) noexcept;
```

```
constexpr bool compare_exchange_weak(weak_ptr<T>& expected, weak_ptr<T> desired,
memory_order order = memory_order::seq_cst) noexcept;
```

*Effects*: Equivalent to: return compare_exchange_weak(expected, desired, order, fail_order); where fail_order is the same as order except that a value of memory_order::acq_rel shall be replaced by the value memory_order::acquire and a value of memory_order::release shall be replaced by the value memory_order::relaxed.

```
constexpr bool compare_exchange_strong(weak_ptr<T>& expected, weak_ptr<T> desired,
memory_order order = memory_order::seq_cst) noexcept;
```

*Effects*: Equivalent to: return compare_exchange_strong(expected, desired, order, fail_order); where fail_order is the same as order except that a value of memory_order::acq_rel shall be replaced by the value memory_order::acquire and a value of memory_order::release shall be replaced by the value memory_order::relaxed.

```
constexpr void wait(weak_ptr<T> old, memory_order order = memory_order::seq_cst) const noexcept;
```

*Remarks*: Two weak_ptr objects are equivalent if they store the same pointer and either share ownership or are both empty.

```
constexpr void notify_one() noexcept;
```

*Effects*: Unblocks the execution of at least one atomic waiting operation that is eligible to be unblocked ([atomics.wait]) by this call, if any such atomic waiting operations exist.

```
constexpr void notify_all() noexcept;
```

*Effects*: Unblocks the execution of all atomic waiting operations that are eligible to be unblocked ([atomics.wait]) by this call.

### 33.5.9 Non-member functions [atomics.nonmembers]

*f*or the pattern atomic_

*f*_explicit invokes the member function

*f*, with the value of the first parameter as the object expression and the values of the remaining parameters (if any) as the arguments of the member function call, in order.

### 33.5.10 Flag type and operations [atomics.flag]

```
constexpr atomic_flag::atomic_flag() noexcept;
```

```
bool atomic_flag_test(const volatile atomic_flag* object) noexcept;
constexpr bool atomic_flag_test(const atomic_flag* object) noexcept;
bool atomic_flag_test_explicit(const volatile atomic_flag* object,
memory_order order) noexcept;
constexpr bool atomic_flag_test_explicit(const atomic_flag* object,
memory_order order) noexcept;
bool atomic_flag::test(memory_order order = memory_order::seq_cst) const volatile noexcept;
constexpr bool atomic_flag::test(memory_order order = memory_order::seq_cst) const noexcept;
```

```
bool atomic_flag_test_and_set(volatile atomic_flag* object) noexcept;
constexpr bool atomic_flag_test_and_set(atomic_flag* object) noexcept;
bool atomic_flag_test_and_set_explicit(volatile atomic_flag* object, memory_order order) noexcept;
constexpr bool atomic_flag_test_and_set_explicit(atomic_flag* object, memory_order order) noexcept;
bool atomic_flag::test_and_set(memory_order order = memory_order::seq_cst) volatile noexcept;
constexpr bool atomic_flag::test_and_set(memory_order order = memory_order::seq_cst) noexcept;
```

```
void atomic_flag_clear(volatile atomic_flag* object) noexcept;
constexpr void atomic_flag_clear(atomic_flag* object) noexcept;
void atomic_flag_clear_explicit(volatile atomic_flag* object, memory_order order) noexcept;
constexpr void atomic_flag_clear_explicit(atomic_flag* object, memory_order order) noexcept;
void atomic_flag::clear(memory_order order = memory_order::seq_cst) volatile noexcept;
constexpr void atomic_flag::clear(memory_order order = memory_order::seq_cst) noexcept;
```

```
void atomic_flag_wait(const volatile atomic_flag* object, bool old) noexcept;
constexpr void atomic_flag_wait(const atomic_flag* object, bool old) noexcept;
void atomic_flag_wait_explicit(const volatile atomic_flag* object,
bool old, memory_order order) noexcept;
constexpr void atomic_flag_wait_explicit(const atomic_flag* object,
bool old, memory_order order) noexcept;
void atomic_flag::wait(bool old, memory_order order =
memory_order::seq_cst) const volatile noexcept;
constexpr void atomic_flag::wait(bool old, memory_order order =
memory_order::seq_cst) const noexcept;
```

```
void atomic_flag_notify_one(volatile atomic_flag* object) noexcept;
constexpr void atomic_flag_notify_one(atomic_flag* object) noexcept;
void atomic_flag::notify_one() volatile noexcept;
constexpr void atomic_flag::notify_one() noexcept;
```

*Effects*: Unblocks the execution of at least one atomic waiting operation that is eligible to be unblocked ([atomics.wait]) by this call, if any such atomic waiting operations exist.

```
void atomic_flag_notify_all(volatile atomic_flag* object) noexcept;
constexpr void atomic_flag_notify_all(atomic_flag* object) noexcept;
void atomic_flag::notify_all() volatile noexcept;
constexpr void atomic_flag::notify_all() noexcept;
```

*Effects*: Unblocks the execution of all atomic waiting operations that are eligible to be unblocked ([atomics.wait]) by this call.

`#define ATOMIC_FLAG_INIT `*see below*

*Remarks*: The macro ATOMIC_FLAG_INIT is defined in such a way that it can be used to initialize an object of type atomic_flag to the clear state.

### 33.5.11 Fences [atomics.fences]

*acquire fence*.

*release fence*.

```
extern "C" constexpr void atomic_thread_fence(memory_order order) noexcept;
```

*Effects*: Depending on the value of order, this operation:

- has no effects, if order == memory_order::relaxed;
- is an acquire fence, if order == memory_order::acquire or order == memory_order::consume;
- is a release fence, if order == memory_order::release;
- is both an acquire fence and a release fence, if order == memory_order::acq_rel;
- is a sequentially consistent acquire and release fence, if order == memory_order::seq_cst.

```
extern "C" constexpr void atomic_signal_fence(memory_order order) noexcept;
```

*Note 1*:

*end note*]

### 33.5.12 C compatibility [stdatomic.h.syn]

*std-atomic*= std::atomic<T>; //

*exposition only*#define _Atomic(T)

*std-atomic*<T> #define ATOMIC_BOOL_LOCK_FREE

*see below*#define ATOMIC_CHAR_LOCK_FREE

*see below*#define ATOMIC_CHAR16_T_LOCK_FREE

*see below*#define ATOMIC_CHAR32_T_LOCK_FREE

*see below*#define ATOMIC_WCHAR_T_LOCK_FREE

*see below*#define ATOMIC_SHORT_LOCK_FREE

*see below*#define ATOMIC_INT_LOCK_FREE

*see below*#define ATOMIC_LONG_LOCK_FREE

*see below*#define ATOMIC_LLONG_LOCK_FREE

*see below*#define ATOMIC_POINTER_LOCK_FREE

*see below*using std::memory_order; //

*see below*using std::memory_order_relaxed; //

*see below*using std::memory_order_consume; //

*see below*using std::memory_order_acquire; //

*see below*using std::memory_order_release; //

*see below*using std::memory_order_acq_rel; //

*see below*using std::memory_order_seq_cst; //

*see below*using std::atomic_flag; //

*see below*using std::atomic_bool; //

*see below*using std::atomic_char; //

*see below*using std::atomic_schar; //

*see below*using std::atomic_uchar; //

*see below*using std::atomic_short; //

*see below*using std::atomic_ushort; //

*see below*using std::atomic_int; //

*see below*using std::atomic_uint; //

*see below*using std::atomic_long; //

*see below*using std::atomic_ulong; //

*see below*using std::atomic_llong; //

*see below*using std::atomic_ullong; //

*see below*using std::atomic_char8_t; //

*see below*using std::atomic_char16_t; //

*see below*using std::atomic_char32_t; //

*see below*using std::atomic_wchar_t; //

*see below*using std::atomic_int8_t; //

*see below*using std::atomic_uint8_t; //

*see below*using std::atomic_int16_t; //

*see below*using std::atomic_uint16_t; //

*see below*using std::atomic_int32_t; //

*see below*using std::atomic_uint32_t; //

*see below*using std::atomic_int64_t; //

*see below*using std::atomic_uint64_t; //

*see below*using std::atomic_int_least8_t; //

*see below*using std::atomic_uint_least8_t; //

*see below*using std::atomic_int_least16_t; //

*see below*using std::atomic_uint_least16_t; //

*see below*using std::atomic_int_least32_t; //

*see below*using std::atomic_uint_least32_t; //

*see below*using std::atomic_int_least64_t; //

*see below*using std::atomic_uint_least64_t; //

*see below*using std::atomic_int_fast8_t; //

*see below*using std::atomic_uint_fast8_t; //

*see below*using std::atomic_int_fast16_t; //

*see below*using std::atomic_uint_fast16_t; //

*see below*using std::atomic_int_fast32_t; //

*see below*using std::atomic_uint_fast32_t; //

*see below*using std::atomic_int_fast64_t; //

*see below*using std::atomic_uint_fast64_t; //

*see below*using std::atomic_intptr_t; //

*see below*using std::atomic_uintptr_t; //

*see below*using std::atomic_size_t; //

*see below*using std::atomic_ptrdiff_t; //

*see below*using std::atomic_intmax_t; //

*see below*using std::atomic_uintmax_t; //

*see below*using std::atomic_is_lock_free; //

*see below*using std::atomic_load; //

*see below*using std::atomic_load_explicit; //

*see below*using std::atomic_store; //

*see below*using std::atomic_store_explicit; //

*see below*using std::atomic_exchange; //

*see below*using std::atomic_exchange_explicit; //

*see below*using std::atomic_compare_exchange_strong; //

*see below*using std::atomic_compare_exchange_strong_explicit; //

*see below*using std::atomic_compare_exchange_weak; //

*see below*using std::atomic_compare_exchange_weak_explicit; //

*see below*using std::atomic_fetch_add; //

*see below*using std::atomic_fetch_add_explicit; //

*see below*using std::atomic_fetch_sub; //

*see below*using std::atomic_fetch_sub_explicit; //

*see below*using std::atomic_fetch_and; //

*see below*using std::atomic_fetch_and_explicit; //

*see below*using std::atomic_fetch_or; //

*see below*using std::atomic_fetch_or_explicit; //

*see below*using std::atomic_fetch_xor; //

*see below*using std::atomic_fetch_xor_explicit; //

*see below*using std::atomic_flag_test_and_set; //

*see below*using std::atomic_flag_test_and_set_explicit; //

*see below*using std::atomic_flag_clear; //

*see below*using std::atomic_flag_clear_explicit; //

*see below*#define ATOMIC_FLAG_INIT

*see below*using std::atomic_thread_fence; //

*see below*using std::atomic_signal_fence; //

*see below*

*using-declaration*for some name A in the synopsis above makes available the same entity as std::A declared in <atomic>.

*using-declaration*

*s*for intN_t, uintN_t, intptr_t, and uintptr_t listed above is defined if and only if the implementation defines the corresponding

*typedef-name*in [atomics.syn].

*Recommended practice*: Implementations should ensure that C and C++ representations of atomic objects are compatible, so that the same object can be accessed as both an _Atomic(T) from C code and an atomic<T> from C++ code.

### Feature test macro

## 17.3.2 Header <version> synopsis [version.syn]

`#define __cpp_lib_constexpr_atomic 2024??L`

## Implementation experience

This was implemented in libc++ & clang by adding `constexpr`

to needed places implementing atomic builtins.

## Impact on existing code

None, currently`std::atomic`

and `std::atomic_ref`

can't be used in constant evaluated code.