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 *integral-type*,
the specialization atomic_ref<*integral-type*> provides
additional atomic operations appropriate to integral types.

[*Note 1*: — *end note*]

namespace std {
template<> struct atomic_ref<*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;
explicit atomic_ref(*integral-type*&);
atomic_ref(const atomic_ref&) noexcept;
atomic_ref& operator=(const atomic_ref&) = delete;
void store(*integral-type*, memory_order = memory_order::seq_cst) const noexcept;
*integral-type* operator=(*integral-type*) const noexcept;
*integral-type* load(memory_order = memory_order::seq_cst) const noexcept;
operator *integral-type*() const noexcept;
*integral-type* exchange(*integral-type*,
memory_order = memory_order::seq_cst) const noexcept;
bool compare_exchange_weak(*integral-type*&, *integral-type*,
memory_order, memory_order) const noexcept;
bool compare_exchange_strong(*integral-type*&, *integral-type*,
memory_order, memory_order) const noexcept;
bool compare_exchange_weak(*integral-type*&, *integral-type*,
memory_order = memory_order::seq_cst) const noexcept;
bool compare_exchange_strong(*integral-type*&, *integral-type*,
memory_order = memory_order::seq_cst) const noexcept;
*integral-type* fetch_add(*integral-type*,
memory_order = memory_order::seq_cst) const noexcept;
*integral-type* fetch_sub(*integral-type*,
memory_order = memory_order::seq_cst) const noexcept;
*integral-type* fetch_and(*integral-type*,
memory_order = memory_order::seq_cst) const noexcept;
*integral-type* fetch_or(*integral-type*,
memory_order = memory_order::seq_cst) const noexcept;
*integral-type* fetch_xor(*integral-type*,
memory_order = memory_order::seq_cst) const noexcept;
*integral-type* fetch_max(*integral-type*,
memory_order = memory_order::seq_cst) const noexcept;
*integral-type* fetch_min(*integral-type*,
memory_order = memory_order::seq_cst) const noexcept;
*integral-type* operator++(int) const noexcept;
*integral-type* operator--(int) const noexcept;
*integral-type* operator++() const noexcept;
*integral-type* operator--() const noexcept;
*integral-type* operator+=(*integral-type*) const noexcept;
*integral-type* operator-=(*integral-type*) const noexcept;
*integral-type* operator&=(*integral-type*) const noexcept;
*integral-type* operator|=(*integral-type*) const noexcept;
*integral-type* operator^=(*integral-type*) const noexcept;
void wait(*integral-type*, memory_order = memory_order::seq_cst) const noexcept;
void notify_one() const noexcept;
void notify_all() const noexcept;
};
}

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

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.

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