[atomics.types.int]

There are specializations of the atomic class template for each character type ([basic.fundamental]), each standard integer type, and any other types needed by the typedefs in the header <cstdint>.

For each such type integral-type, the specialization atomic<integral-type> provides additional atomic operations appropriate to integral types.

[Note 1:

The specialization atomic<bool> uses the primary template ([atomics.types.generic]).

— end note]

namespace std { template<> struct atomic<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 is_lock_free() 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; void store_add(integral-type, memory_order = memory_order::seq_cst) volatile noexcept; constexpr void store_add(integral-type, memory_order = memory_order::seq_cst) noexcept; void store_sub(integral-type, memory_order = memory_order::seq_cst) volatile noexcept; constexpr void store_sub(integral-type, memory_order = memory_order::seq_cst) noexcept; void store_and(integral-type, memory_order = memory_order::seq_cst) volatile noexcept; constexpr void store_and(integral-type, memory_order = memory_order::seq_cst) noexcept; void store_or(integral-type, memory_order = memory_order::seq_cst) volatile noexcept; constexpr void store_or(integral-type, memory_order = memory_order::seq_cst) noexcept; void store_xor(integral-type, memory_order = memory_order::seq_cst) volatile noexcept; constexpr void store_xor(integral-type, memory_order = memory_order::seq_cst) noexcept; void store_max(integral-type, memory_order = memory_order::seq_cst) volatile noexcept; constexpr void store_max(integral-type, memory_order = memory_order::seq_cst) noexcept; void store_min(integral-type, memory_order = memory_order::seq_cst) volatile noexcept; constexpr void store_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; }; }

The atomic integral specializations are standard-layout structs.

They each have a trivial destructor.

The following operations perform arithmetic computations.

The correspondence among key, operator, and computation is specified in Table 155 .

Table 155 — Atomic arithmetic computations [tab:atomic.types.int.comp]

🔗 *key*	Op	Computation	*key*	Op	Computation
🔗 add	+	addition	and	&	bitwise and
🔗 sub	-	subtraction	or	\|	bitwise inclusive or
🔗 max		maximum	xor	^	bitwise exclusive or
🔗 min		minimum

🔗

integral-type fetch_key(integral-type operand,
                         memory_order order = memory_order::seq_cst) volatile noexcept;
constexpr integral-type fetch_key(integral-type operand,
                                   memory_order order = memory_order::seq_cst) noexcept;

Constraints: For the volatile overload of this function, is_always_lock_free is true.

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.

Memory is affected according to the value of order.

These operations are atomic read-modify-write operations ([intro.multithread]).

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.

[Note 2:

There are no undefined results arising from the computation.

— end note]

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.

🔗

void store_key(integral-type operand,
                memory_order order = memory_order::seq_cst) volatile noexcept;
constexpr void store_key(integral-type operand,
                          memory_order order = memory_order::seq_cst) noexcept;

Constraints: For the volatile overload of this function, is_always_lock_free is true.

Preconditions: order is memory_order::relaxed, memory_order::release, or memory_order::seq_cst.

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.

Memory is affected according to the value of order.

These operations are atomic modify-write operations ([atomics.order]).

Remarks: Except for store_max and store_min, for signed integer types, the result is as if the value pointed to by this and parameters were converted to their corresponding unsigned types, the computation performed on those types, and the result converted back to the signed type.

[Note 3:

There are no undefined results arising from the computation.

— end note]

For store_max and store_min, the maximum and minimum computation is performed as if by max and min algorithms ([alg.min.max]), respectively, with the value pointed to by this and the first parameter as the arguments.

🔗

integral-type operator op=(integral-type operand) volatile noexcept;
constexpr integral-type operator op=(integral-type operand) noexcept;

Constraints: For the volatile overload of this function, is_always_lock_free is true.

Effects: Equivalent to: return fetch_key(operand) op operand;