D.3.10. Специализации std::atomic<integral-type>

We use cookies. Read the Privacy and Cookie Policy

Специализации std::atomic<integral-type> шаблона класса std::atomic дают атомарный целочисленный тип для каждого фундаментального целочисленного типа, с полным набором операций.

Ниже перечислены все такие специализации шаблона std::atomic<>:

std::atomic<char>

std::atomic<signed char>

std::atomic<unsigned char>

std::atomic<short>

std::atomic<unsigned short>

std::atomic<int>

std::atomic<unsigned>

std::atomic<long>

std::atomic<unsigned long>

std::atomic<long long>

std::atomic<unsigned long long>

std::atomic<wchar_t>

std::atomic<char16_t>

std::atomic<char32_t>

Экземпляры этих специализаций не удовлетворяют требованиям концепций CopyConstructible и CopyAssignable, поскольку такие операции невозможно выполнить атомарно.

Определение класса

template<>

struct atomic<integral-type> {

 atomic() noexcept = default;

 constexpr atomic(integral-type) noexcept;

 bool operator=(integral-type) volatile noexcept;

 atomic(const atomic&) = delete;

 atomic& operator=(const atomic&) = delete;

 atomic& operator=(const atomic&) volatile = delete;

 bool is_lock_free() const volatile noexcept;

 bool is_lock_free() const noexcept;

 void store(

  integral-type, memory_order = memory_order_seq_cst)

  volatile noexcept;

 void store(

  integral-type, memory_order = memory_order_seq_cst) noexcept;

 integral-type load(memory_order = memory_order_seq_cst)

  const volatile noexcept;

 integral-type load(

  memory_order = memory_order_seq_cst) const noexcept;

 integral-type exchange(

  integral-type,

  memory_order = memory_order_seq_cst) volatile noexcept;

 integral-type exchange(

  integral-type, memory_order = memory_order_seq_cst) noexcept;

 bool compare_exchange_strong(

  integral-type & old_value, integral-type new_value,

  memory_order order = memory_order_seq_cst)

  volatile noexcept;

 bool compare_exchange_strong(

  integral-type & old_value, integral-type new_value,

  memory_order order = memory_order_seq_cst) noexcept;

 bool compare_exchange_strong(

  integral-type & old_value, integral-type new_value,

  memory_order success_order, memory_order failure_order)

  volatile noexcept;

 bool compare_exchange_strong(

  integral-type & old_value, integral-type new_value,

  memory_order success_order,

  memory_order failure_order) noexcept;

 bool compare_exchange_weak(

  integral-type & old_value, integral-type new_value,

  memory_order order = memory_order_seq_cst) volatile noexcept;

 bool compare_exchange_weak(

  integral-type & old_value, integral-type new_value,

  memory_order order = memory_order_seq_cst) noexcept;

 bool compare_exchange_weak(

  integral-type & old_value, integral-type new_value,

  memory_order success_order, memory_order failure_order)

  volatile noexcept;

 bool compare_exchange_weak(

  integral-type & old_value, integral-type new_value,

  memory_order success_order,

  memory_order failure_order) noexcept;

 operator integral-type() const volatile noexcept;

 operator integral-type() const noexcept;

 integral-type fetch_add(

  integral-type, memory_order = memory_order_seq_cst)

  volatile noexcept;

 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;

 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;

 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;

 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;

 integral-type fetch_xor(

  integral-type, memory_order = memory_order_seq_cst) noexcept;

 integral-type operator++() volatile noexcept;

 integral-type operator++() noexcept;

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

 integral-type operator++(int) noexcept;

 integral-type operator--() volatile noexcept;

 integral-type operator--() noexcept;

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

 integral-type operator--(int) noexcept;

 integral-type operator+=(integral-type) volatile noexcept;

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

 integral-type operator-=(integral-type) volatile noexcept;

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

 integral-type operator&=(integral-type) volatile noexcept;

 integral-type operator&=(integral-type) noexcept;

 integral-type operator|=(integral-type) volatile noexcept;

 integral-type operator|=(integral-type) noexcept;

 integral-type operator^=(integral-type) volatile noexcept;

 integral-type operator^=(integral-type) noexcept;

};

bool atomic_is_lock_free(

 volatile const atomic<integral-type>*) noexcept;

bool atomic_is_lock_free(const atomic<integral-type>*) noexcept;

void atomic_init(

 volatile atomic<integral-type>*, integral-type) noexcept;

void atomic_init(atomic<integral-type>*, integral-type) noexcept;

integral-type atomic_exchange(

 volatile atomic<integral-type>*, integral-type) noexcept;

integral-type atomic_exchange(

 atomic<integral-type>*, integral-type) noexcept;

integral-type atomic_exchange_explicit(

 volatile atomic<integral-type>*, integral-type, memory_order)

 noexcept;

integral-type atomic_exchange_explicit(

 atomic<integral-type>*, integral-type, memory_order) noexcept;

void atomic_store(

 volatile atomic<integral-type>*, integral-type) noexcept;

void atomic_store(

 atomic<integral-type>*, integral-type) noexcept;

void atomic_store_explicit(

 volatile atomic<integral-type>*,

 integral-type, memory_order) noexcept;

void atomic_store_explicit(

 atomic<integral-type>*, integral-type, memory_order) noexcept;

integral-type atomic_load(

 volatile const atomic<integral-type>*) noexcept;

integral-type atomic_load(

 const atomic<integral-type>*) noexcept;

integral-type atomic_load_explicit(

 volatile const atomic<integral-type>*, memory_order) noexcept;

integral-type atomic_load_explicit(

 const atomic<integral-type>*, memory_order) noexcept;

bool atomic_compare_exchange_strong(

 volatile atomic<integral-type>*, integral-type * old_value,

 integral-type new_value) noexcept;

bool atomic_compare_exchange_strong(

 atomic<integral-type>*,

 integral-type * old_value, integral-type new_value) noexcept;

bool atomic_compare_exchange_strong_explicit(

 volatile atomic<integral-type>*,

 integral-type * old_value, integral-type new_value,

 memory_order success_order,

 memory_order failure_order) noexcept;

bool atomic_compare_exchange_strong_explicit(

 atomic<integral-type>*,

 integral-type * old_value, integral-type new_value,

 memory_order success_order,

 memory_order failure_order) noexcept;

bool atomic_compare_exchange_weak(

 volatile atomic<integral-type>*,

 integral-type * old_value, integral-type new_value) noexcept;

bool atomic_compare_exchange_weak(

 atomic<integral-type>*,

 integral-type * old_value, integral-type new_value) noexcept;

bool atomic_compare_exchange_weak_explicit(

 volatile atomic<integral-type>*,

 integral-type * old_value, integral-type new_value,

 memory_order success_order,

 memory_order failure_order) noexcept;

bool atomic_compare_exchange_weak_explicit(

 atomic<integral-type>*,

 integral-type * old_value, integral-type new_value,

 memory_order success_order,

 memory_order failure_order) noexcept;

 integral-type atomic_fetch_add(

 volatile atomic<integral-type>*, integral-type) noexcept;

integral-type atomic_fetch_add(

 atomic<integral-type>*, integral-type) noexcept;

integral-type atomic_fetch_add_explicit(

 volatile atomic<integral-type>*, integral-type,

 memory_order) noexcept;

integral-type atomic_fetch_add_explicit(

 atomic<integral-type>*, integral-type, memory_order) noexcept;

integral-type atomic_fetch_sub(

 volatile atomic<integral-type>*, integral-type) noexcept;

integral-type atomic_fetch_sub(

 atomic<integral-type>*, integral-type) noexcept;

integral-type atomic_fetch_sub_explicit(

 volatile atomic<integral-type>*,

 integral-type, memory_order) noexcept;

integral-type atomic_fetch_sub_explicit(

 atomic<integral-type>*, integral-type, memory_order) noexcept;

integral-type atomic_fetch_and(

 volatile atomic<integral-type>*, integral-type) noexcept;

integral-type atomic_fetch_and(

 atomic<integral-type>*, integral-type) noexcept;

integral-type atomic_fetch_and_explicit(

 volatile atomic<integral-type>*,

 integral-type, memory_order) noexcept;

integral-type atomic_fetch_and_explicit(

 atomic<integral-type>*, integral-type, memory_order) noexcept;

integral-type atomic_fetch_or(

 volatile atomic<integral-type>*, integral-type) noexcept;

integral-type atomic_fetch_or(

 atomic<integral-type>*, integral-type) noexcept;

integral-type atomic_fetch_or_explicit(

 volatile atomic<integral-type>*,

 integral-type, memory_order) noexcept;

integral-type atomic_fetch_or_explicit(

 atomic<integral-type>*, integral-type, memory_order) noexcept;

integral-type atomic_fetch_xor(

 volatile atomic<integral-type>*, integral-type) noexcept;

integral-type atomic_fetch_xor(

 atomic<integral-type>*, integral-type) noexcept;

integral-type atomic_fetch_xor_explicit(

 volatile atomic<integral-type>*,

 integral-type, memory_order) noexcept;

integral-type atomic_fetch_xor_explicit(

 atomic<integral-type>*, integral-type, memory_order) noexcept;

Те операции, которые предоставляются также основным шаблоном (см. D.3.8), имеют точно такую же семантику.

STD::ATOMIC<INTEGRAL-TYPE>::FETCH_ADD , ФУНКЦИЯ-ЧЛЕН

Атомарно загружает значение и заменяет его суммой его самого и аргумента i.

Объявление

fetch_add(

 integral-type i, memory_order order = memory_order_seq_cst)

 volatile noexcept;

integral-type fetch_add(

 integral-type i, memory_order order = memory_order_seq_cst)

 noexcept;

Результат

Атомарно возвращает прежнее значение *this и сохраняет в *this значение old-value + i.

Возвращаемое значение

Значение *this непосредственно перед сохранением.

Исключения

Нет.

Примечание. Это атомарная операция чтения-модификации-записи для ячейки памяти, содержащей *this.

STD::ATOMIC_FETCH_ADD , ФУНКЦИЯ, HE ЯВЛЯЮЩАЯСЯ ЧЛЕНОМ КЛАССА

Атомарно читает значение из экземпляра atomic<integral-type> и заменяет его суммой этого значения и аргумента i.

Объявление

integral-type atomic_fetch_add(

 volatile atomic<integral-type>* p, integral-type i) noexcept;

integral-type atomic_fetch_add(

 atomic<integral-type>* p, integral-type i) noexcept;

Результат

return p->fetch_add(i);

STD::ATOMIC_FETCH_ADD_EXPLICIT , ФУНКЦИЯ, HE ЯВЛЯЮЩАЯСЯ ЧЛЕНОМ

КЛАССА

Атомарно читает значение из экземпляра atomic<integral-type> и заменяет его суммой этого значения и аргумента i.

Объявление

integral-type atomic_fetch_add_explicit(

 volatile atomic<integral-type>* p, integral-type i,

 memory_order order) noexcept;

integral-type atomic_fetch_add_explicit(

 atomic<integral-type>* p, integral-type i,

 memory_order order) noexcept;

Результат

return p->fetch_add(i,order);

STD::ATOMIC<INTEGRAL-TYPE>::FETCH_SUB , ФУНКЦИЯ-ЧЛЕН

Атомарно читает значение и заменяет его разностью этого значения и аргумента i.

Объявление

integral-type fetch_sub(

 integral-type i,

 memory_order order = memory_order_seq_cst) volatile noexcept;

integral-type fetch_sub(

 integral-type i,

 memory_order order = memory_order_seq_cst) noexcept;

Результат

Атомарно возвращает прежнее значение *this и сохраняет в *this значение old-value - i.

Возвращаемое значение

Значение *this непосредственно перед сохранением.

Исключения

Нет.

Примечание. Это атомарная операция чтения-модификации-записи для ячейки памяти, содержащей *this.

STD::ATOMIC_FETCH_SUB , ФУНКЦИЯ, НЕ ЯВЛЯЮЩАЯСЯ ЧЛЕНОМ КЛАССА

Атомарно читает значение из экземпляра atomic<integral-type> и заменяет его разностью этого значения и аргумента i.

Объявление

integral-type atomic_fetch_sub(

 volatile atomic<integral-type>* p, integral-type i) noexcept;

integral-type atomic_fetch_sub(

 atomic<integral-type>* p, integral-type i) noexcept;

Результат

return p->fetch_sub(i);

STD::ATOMIC_FETCH_SUB_EXPLICIT , ФУНКЦИЯ, HE ЯВЛЯЮЩАЯСЯ ЧЛЕНОМ КЛАССА

Атомарно читает значение из экземпляра atomic<integral-type> и заменяет его разностью этого значения и аргумента i.

Объявление

integral-type atomic_fetch_sub_explicit(

 volatile atomic<integral-type>* p,

 integral-type i, memory_order order) noexcept;

integral-type atomic_fetch_sub_explicit(

 atomic<integral-type>* p,

 integral-type i, memory_order order) noexcept;

Результат

return p->fetch_sub(i, order);

STD::ATOMIC<INTEGRAL-TYPE>::FETCH_AND , ФУНКЦИЯ-ЧЛЕН

Атомарно загружает значение и заменяет его результатом операции поразрядное-и между этим значением и аргументом i.

Объявление

integral-type fetch_and(

 integral-type i, memory_order order = memory_order_seq_cst)

 volatile noexcept;

integral-type fetch_and(

 integral-type i, memory_order order = memory_order_seq_cst)

 noexcept;

Результат

Атомарно возвращает прежнее значение *this и сохраняет в *this значение old-value & i.

Возвращаемое значение

Значение *this непосредственно перед сохранением.

Исключения

Нет.

Примечание. Это атомарная операция чтения-модификации-записи для ячейки памяти, содержащей *this.

STD::ATOMIC_FETCH_AND , ФУНКЦИЯ, НЕ ЯВЛЯЮЩАЯСЯ ЧЛЕНОМ КЛАССА

Атомарно читает значение из экземпляра atomic<integral-type> и заменяет его результатом операции поразрядное-и между этим значением и аргументом i. Объявление

integral-type atomic_fetch_and(

 volatile atomic<integral-type>* p, integral-type i) noexcept;

integral-type atomic_fetch_and(

 atomic<integral-type>* p, integral-type i) noexcept;

Результат

return p->fetch_and(i);

STD::ATOMIC_FETCH_AND_EXPLICIT , ФУНКЦИЯ, HE ЯВЛЯЮЩАЯСЯ ЧЛЕНОМ КЛАССА

Атомарно читает значение из экземпляра atomic<integral-type> и заменяет его результатом операции поразрядное-и между этим значением и аргументом i.

Объявление

integral-type atomic_fetch_and_explicit(

 volatile atomic<integral-type>* p,

 integral-type i, memory_order order) noexcept;

integral-type atomic_fetch_and_explicit(

 atomic<integral-type>* p,

 integral-type i, memory_order order) noexcept;

Результат

return p->fetch_and(i,order);

STD::ATOMIC<INTEGRAL-TYPE>::FETCH_OR , ФУНКЦИЯ-ЧЛЕН

Атомарно загружает значение и заменяет его результатом операции поразрядное-или между этим значением и аргументом i.

Объявление

integral-type fetch_or(

 integral-type i, memory_order order = memory_order_seq_cst)

volatile noexcept;

integral-type fetch_or(

 integral-type i, memory_order order = memory_order_seq_cst)

 noexcept;

Результат

Атомарно возвращает прежнее значение *this и сохраняет в *this значение old-value | i.

Возвращаемое значение

Значение *this непосредственно перед сохранением.

Исключения

Нет.

Примечание. Это атомарная операция чтения-модификации-записи для ячейки памяти, содержащей *this.

STD::ATOMIC_FETCH_OR , ФУНКЦИЯ, HE ЯВЛЯЮЩАЯСЯ ЧЛЕНОМ КЛАССА

Атомарно читает значение из экземпляра atomic<integral-type> и заменяет его результатом операции поразрядное-или между этим значением и аргументом i.

Объявление

integral-type atomic_fetch_or(

 volatile atomic<integral-type>* p, integral-type i) noexcept;

integral-type atomic_fetch_or(

 atomic<integral-type>* p, integral-type i) noexcept;

Результат

return p->fetch_or(i);

STD::ATOMIC_FETCH_OR_EXPLICIT , ФУНКЦИЯ, HE ЯВЛЯЮЩАЯСЯ ЧЛЕНОМ КЛАССА

Атомарно читает значение из экземпляра atomic<integral-type> и заменяет его результатом операции поразрядное-или между этим значением и аргументом i.

Объявление

integral-type atomic_fetch_or_explicit(

 volatile atomic<integral-type>* p,

 integral-type i, memory_order order) noexcept;

integral-type atomic_fetch_or_explicit(

 atomic<integral-type>* p,

 integral-type i, memory_order order) noexcept;

Результат

return p->fetch_or(i, order);

STD::ATOMIC<INTEGRAL-TYPE>::FETCH_XOR , ФУНКЦИЯ-ЧЛЕН

Атомарно загружает значение и заменяет его результатом операции поразрядное исключающее-или между этим значением и аргументом i.

Объявление

integral-type fetch_xor(

 integral-type i, memory_order order = memory_order_seq_cst)

 volatile noexcept;

integral-type fetch_xor(

 integral-type i, memory_order order = memory_order_seq_cst)

 noexcept;

Результат

Атомарно возвращает прежнее значение *this и сохраняет в *this значение old-value ^ i.

Возвращаемое значение

Значение *this непосредственно перед сохранением.

Исключения

Нет.

Примечание. Это атомарная операция чтения-модификации-записи для ячейки памяти, содержащей *this.

STD::ATOMIC_FETCH_XOR , ФУНКЦИЯ, НЕ ЯВЛЯЮЩАЯСЯ ЧЛЕНОМ КЛАССА

Атомарно читает значение из экземпляра atomic<integral-type> и заменяет его результатом операции поразрядное исключающее-или между этим значением и аргументом i.

Объявление

integral-type atomic_fetch_xor(

 volatile atomic<integral-type>* p, integral-type i) noexcept;

integral-type atomic_fetch_xor(

 atomic<integral-type>* p, integral-type i) noexcept;

Результат

return p->fetch_xor(i);

STD::ATOMIC_FETCH_XOR_EXPLICIT , ФУНКЦИЯ, HE ЯВЛЯЮЩАЯСЯ ЧЛЕНОМ КЛАССА

Атомарно читает значение из экземпляра atomic<integral-type> и заменяет его результатом операции поразрядное исключающее-или между этим значением и аргументом i.

Объявление

integral-type atomic_fetch_xor_explicit(

 volatile atomic<integral-type>* p,

 integral-type i, memory_order order) noexcept;

integral-type atomic_fetch_xor_explicit(

 atomic<integral-type>* p,

 integral-type i, memory_order order) noexcept;

Результат

return p->fetch_xor(i,order);

STD::ATOMIC<INTEGRAL-TYPE>::OPERATOR++ , ОПЕРАТОР ПРЕДИНКРЕМЕНТА

Атомарно инкрементирует значение, хранящееся в *this, и возвращает новое значение.

Объявление

integral-type operator++() volatile noexcept;

integral-type operator++() noexcept;

Результат

return this->fetch_add(1) + 1;

STD::ATOMIC<INTEGRAL-TYPE>::OPERATOR++ , ОПЕРАТОР ПОСТИНКРЕМЕНТА

Атомарно инкрементирует значение, хранящееся в *this, и возвращает старое значение.

Объявление

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

integral-type operator++(int) noexcept;

Результат

return this->fetch_add(1);

STD::ATOMIC<INTEGRAL-TYPE>::OPERATOR-- , ОПЕРАТОР ПРЕДЕКРЕМЕНТА

Атомарно декрементирует значение, хранящееся в *this, и возвращает новое значение.

Объявление

integral-type operator--() volatile noexcept;

integral-type operator--() noexcept;

Результат

return this->fetch_sub(1) - 1;

STD::ATOMIC<INTEGRAL-TYPE>::OPERATOR-- , ОПЕРАТОР ПОСТДЕКРЕМЕНТА

Атомарно декрементирует значение, хранящееся в *this, и возвращает старое значение.

Объявление

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

integral-type operator--(int) noexcept;

Результат

return this->fetch_sub(1);

STD::ATOMIC<INTEGRAL-TYPE>::OPERATOR+= , СОСТАВНОЙ ОПЕРАТОР ПРИСВАИВАНИЯ

Атомарно складывает значение аргумента со значением, хранящимся в *this, и возвращает новое значение.

Объявление

integral-type operator+=(integral-type i) volatile noexcept;

integral-type operator+=(integral-type i) noexcept;

Результат

return this->fetch_add(i) + i;

STD::ATOMIC<INTEGRAL-TYPE>::OPERATOR-= , СОСТАВНОЙ ОПЕРАТОР ПРИСВАИВАНИЯ

Атомарно вычитает значение аргумента из значения, хранящегося в *this, и возвращает новое значение.

Объявление

integral-type operator-=(integral-type i) volatile noexcept;

integral-type operator-=(integral-type i) noexcept;

Результат

return this->fetch_sub(i, std::memory_order_seq_cst) - i;

STD::ATOMIC<INTEGRAL-TYPE>::OPERATOR&= , СОСТАВНОЙ ОПЕРАТОР ПРИСВАИВАНИЯ

Атомарно заменяет значение, хранящееся в *this, результатом операции поразрядное-и между этим значением и значением аргумента и возвращает новое значение.

Объявление

integral-type operator&=(integral-type i) volatile noexcept;

integral-type operator&=(integral-type i) noexcept;

Результат

return this->fetch_and(i) & i;

STD::ATOMIC<INTEGRAL-TYPE>::OPERATOR|= , СОСТАВНОЙ ОПЕРАТОР ПРИСВАИВАНИЯ

Атомарно заменяет значение, хранящееся в *this, результатом операции поразрядное-или между этим значением и значением аргумента и возвращает новое значение.

Объявление

integral-type operator|=(integral-type i) volatile noexcept;

integral-type operator|=(integral-type i) noexcept;

Результат

return this->fetch_or(i, std::memory_order_seq_cst) | i;

STD::ATOMIC<INTEGRAL-TYPE>::OPERATOR^= , СОСТАВНОЙ ОПЕРАТОР ПРИСВАИВАНИЯ

Атомарно заменяет значение, хранящееся в *this, результатом операции поразрядное исключающее-или между этим значением и значением аргумента и возвращает новое значение.

Объявление

integral-type operator^=(integral-type i) volatile noexcept;

integral-type operator^=(integral-type i) noexcept;

Результат

return this->fetch_xor(i, std::memory_order_seq_cst) ^ i;

STD::ATOMIC<T*> , ЧАСТИЧНАЯ СПЕЦИАЛИЗАЦИЯ

Частичная специализация std::atomic<T*> шаблона std::atomic предоставляет атомарный тип для любого указательного типа, с полным набором операций.

Экземпляры std::atomic<T*> не удовлетворяют требованиям концепций CopyConstructible и CopyAssignable, поскольку такие операции невозможно выполнить атомарно.

Определение класса

template<typename T>

struct atomic<T*> {

 atomic() noexcept = default;

 constexpr atomic(T*) noexcept;

 bool operator=(T*) volatile;

 bool operator=(T*);

 atomic(const atomic&) = delete;

 atomic& operator=(const atomic&) = delete;

 atomic& operator=(const atomic&) volatile = delete;

 bool is_lock_free() const volatile noexcept;

 bool is_lock_free() const noexcept;

 void store(T*, memory_order = memory_order_seq_cst)

  volatile noexcept;

 void store(T*, memory_order = memory_order_seq_cst) noexcept;

 T* load(memory_order = memory_order_seq_cst)

  const volatile noexcept;

 T* load(memory_order = memory_order_seq_cst) const noexcept;

 T* exchange(T*, memory_order = memory_order_seq_cst)

  volatile noexcept;

 T* exchange(T*, memory_order = memory_order_seq_cst) noexcept;

 bool compare_exchange_strong(

  T* & old_value, T* new_value,

  memory_order order = memory_order_seq_cst)

  volatile noexcept;

 bool compare_exchange_strong(

  T* & old_value, T* new_value,

  memory_order order = memory_order_seq_cst) noexcept;

 bool compare_exchange_strong(

  T* & old_value, T* new_value,

  memory_order success_order, memory_order failure_order)

  volatile noexcept;

 bool compare_exchange_strong(

  T* & old_value, T* new_value,

  memory_order success_order,

  memory_order failure_order) noexcept;

 bool compare_exchange_weak(

  T* & old_value, T* new_value,

  memory_order order = memory_order_seq_cst) volatile noexcept;

 bool compare_exchange_weak(

  T* & old_value, T* new_value,

  memory_order order = memory_order_seq_cst) noexcept;

 bool compare_exchange_weak(

  T* & old_value, T* new_value,

  memory_order success_order, memory_order failure_order)

  volatile noexcept;

 bool compare_exchange_weak(

  T* & old_value, T* new_value,

  memory_order success_order,

  memory_order failure_order) noexcept;

 operator T*() const volatile noexcept;

 operator T*() const noexcept;

 T* fetch_add(

  ptrdiff_t, memory_order = memory_order_seq_cst)

  volatile noexcept;

 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;

 T* fetch_sub(

  ptrdiff_t, memory_order = memory_order_seq_cst) noexcept;

 T* operator++() volatile noexcept;

 T* operator++() noexcept;

 T* operator++(int) volatile noexcept;

 T* operator++(int) noexcept;

 T* operator--() volatile noexcept;

 T* operator--() noexcept;

 T* operator--(int) volatile noexcept;

 T* operator--(int) noexcept;

 T* operator+=(ptrdiff_t) volatile noexcept;

 T* operator+=(ptrdiff_t) noexcept;

 T* operator-=(ptrdiff_t) volatile noexcept;

 T* operator-=(ptrdiff_t) noexcept;

};

bool atomic_is_lock_free(volatile const atomic<T*>*) noexcept;

bool atomic_is_lock_free(const atomic<T*>*) noexcept;

void atomic_init(volatile atomic<T*>*, T*) noexcept;

void atomic_init(atomic<T*>*, T*) noexcept;

T* atomic_exchange(volatile atomic<T*>*, T*) noexcept;

T* atomic_exchange(atomic<T*>*, T*) noexcept;

T* atomic_exchange_explicit(

 volatile atomic<T*>*, T*, memory_order) noexcept;

T* atomic_exchange_explicit(

 atomic<T*>*, T*, memory_order) noexcept;

void atomic_store(volatile atomic<T*>*, T*) noexcept;

void atomic_store(atomic<T*>*, T*) noexcept;

void atomic_store_explicit(

 volatile atomic<T*>*, T*, memory_order) noexcept;

void atomic_store_explicit(

 atomic<T*>*, T*, memory_order) noexcept;

T* atomic_load(volatile const atomic<T*>*) noexcept;

T* atomic_load(const atomic<T*>*) noexcept;

T* atomic_load_explicit(

 volatile const atomic<T*>*, memory_order) noexcept;

T* atomic_load_explicit(

 const atomic<T*>*, memory_order) noexcept;

bool atomic_compare_exchange_strong(

 volatile atomic<T*>*, T** old_value, T* new_value) noexcept;

bool atomic_compare_exchange_strong(

 volatile atomic<T*>*, T** old_value, T* new_value) noexcept;

bool atomic_compare_exchange_strong_explicit(

 atomic<T*>*, T** old_value, T* new_value,

 memory_order success_order,

 memory_order failure_order) noexcept;

bool atomic_compare_exchange_strong_explicit(

 atomic<T*>*, T** old_value, T* new_value,

 memory_order success_order,

 memory_order failure_order) noexcept;

bool atomic_compare_exchange_weak(

 volatile atomic<T*>*, T** old_value, T* new_value) noexcept;

bool atomic_compare_exchange_weak(

 atomic<T*>*, T** old_value, T* new_value) noexcept;

bool atomic_compare_exchange_weak_explicit(

 volatile atomic<T*>*,

 T** old_value, T* new_value,

 memory_order success_order,

 memory_order failure_order) noexcept;

bool atomic_compare_exchange_weak_explicit(

 atomic<T*>*, T** old_value, T* new_value,

 memory_order success_order,

 memory_order failure_order) noexcept;

T* atomic_fetch_add(volatile atomic<T*>*, ptrdiff_t) noexcept;

T* atomic_fetch_add(atomic<T*>*, ptrdiff_t) noexcept;

T* atomic_fetch_add_explicit(

 volatile atomic<T*>*, ptrdiff_t, memory_order) noexcept;

T* atomic_fetch_add_explicit(

 atomic<T*>*, ptrdiff_t, memory_order) noexcept;

T* atomic_fetch_sub(volatile atomic<T*>*, ptrdiff_t) noexcept;

T* atomic_fetch_sub(atomic<T*>*, ptrdiff_t) noexcept;

T* atomic_fetch_sub_explicit(

 volatile atomic<T*>*, ptrdiff_t, memory_order) noexcept;

T* atomic_fetch_sub_explicit(

 atomic<T*>*, ptrdiff_t, memory_order) noexcept;

Те операции, которые предоставляются также основным шаблоном (см. приложение D.3.8), имеют точно такую же семантику.

STD::ATOMIC<T*>::FETCH_ADD , ФУНКЦИЯ-ЧЛЕН

Атомарно загружает значение, заменяет его суммой этого значения и аргумента i, применяя стандартные правила арифметики указателей, и возвращает старое значение.

Объявление

T* fetch_add(

 ptrdiff_t i, memory_order order = memory_order_seq_cst)

 volatile noexcept;

T* fetch_add(

 ptrdiff_t i, memory_order order = memory_order_seq_cst) noexcept;

Результат

Атомарно возвращает текущее значение *this и сохраняет в *this значение old-value + i.

Возвращаемое значение

Значение *this непосредственно перед сохранением.

Исключения

Нет.

Примечание. Это атомарная операция чтения-модификации-записи для ячейки памяти, содержащей *this.

STD::ATOMIC_FETCH_ADD_EXPLICIT , ФУНКЦИЯ, НЕ ЯВЛЯЮЩАЯСЯ ЧЛЕНОМ КЛАССА

Атомарно читает значение из экземпляра atomic<T*> и заменяет его суммой этого значения и аргумента i, применяя стандартные правила арифметики указателей.

Объявление

T* atomic_fetch_add_explicit(

 volatile atomic<T*>* p, ptrdiff_t i, memory_order order)

 noexcept;

T* atomic_fetch_add_explicit(

 atomic<T*>* p, ptrdiff_t i, memory_order order) noexcept;

Результат

return p->fetch_add(i, order);

STD::ATOMIC<T*>::FETCH_SUB , ФУНКЦИЯ-ЧЛЕН

Атомарно загружает значение, заменяет его разностью этого значения и аргумента i, применяя стандартные правила арифметики указателей, и возвращает старое значение.

Объявление

T* fetch_sub(

 ptrdiff_t i, memory_order order = memory_order_seq_cst)

 volatile noexcept;

T* fetch_sub(

 ptrdiff_t i, memory_order order = memory_order_seq_cst)

 noexcept;

Результат

Атомарно возвращает текущее значение *this и сохраняет в *this значение old-value - i.

Возвращаемое значение

Значение *this непосредственно перед сохранением.

Исключения

Нет.

Примечание. Это атомарная операция чтения-модификации-записи для ячейки памяти, содержащей *this.

STD::ATOMIC_FETCH_SUB , ФУНКЦИЯ, НЕ ЯВЛЯЮЩАЯСЯ ЧЛЕНОМ КЛАССА

Атомарно читает значение из экземпляра atomic<T*> и заменяет его разностью этого значения и аргумента i, применяя стандартные правила арифметики указателей.

Объявление

T* atomic_fetch_sub(

 volatile atomic<T*>* p, ptrdiff_t i) noexcept;

T* atomic_fetch_sub(atomic<T*>* p, ptrdiff_t i) noexcept;

Результат

return p->fetch_sub(i);

STD::ATOMIC_FETCH_SUB_EXPLICIT , ФУНКЦИЯ, HE ЯВЛЯЮЩАЯСЯ ЧЛЕНОМ КЛАССА

Атомарно читает значение из экземпляра atomic<T*> и заменяет его разностью этого значения и аргумента i, применяя стандартные правила арифметики указателей.

Объявление

T* atomic_fetch_sub_explicit(

 volatile atomic<T*>* p, ptrdiff_t i, memory_order order)

 noexcept;

T* atomic_fetch_sub_explicit(

 atomic<T*>* p, ptrdiff_t i, memory_order order) noexcept;

Результат

return p->fetch_sub(i, order);

STD::ATOMIC<T*>::OPERATOR++ , ОПЕРАТОР ПРЕДИНКРЕМЕНТА

Атомарно инкрементирует значение, хранящееся в *this, применяя стандартные правила арифметики указателей, и возвращает новое значение.

Объявление

T* operator++() volatile noexcept;

T* operator++() noexcept;

Результат

return this->fetch_add(1) + 1;

STD::ATOMIC<T*>::OPERATOR++ , ОПЕРАТОР ПОСТИНКРЕМЕНТА

Атомарно инкрементирует значение, хранящееся в *this, и возвращает старое значение.

Объявление

T* operator++(int) volatile noexcept;

T* operator++(int) noexcept;

Результат

return this->fetch_add(1);

STD::ATOMIC<T*>::OPERATOR-- , ОПЕРАТОР ПРЕДЕКРЕМЕНТА

Атомарно декрементирует значение, хранящееся в *this, применяя стандартные правила арифметики указателей, и возвращает новое значение.

Объявление

T* operator--() volatile noexcept;

T* operator--() noexcept;

Результат

return this->fetch_sub(1) - 1;

STD::ATOMIC<T*>::OPERATOR-- , ОПЕРАТОР ПОСТДЕКРЕМЕНТА

Атомарно декрементирует значение, хранящееся в *this, применяя стандартные правила арифметики указателей, и возвращает старое значение.

Объявление

T* operator--(int) volatile noexcept;

T* operator--(int) noexcept;

Результат

return this->fetch_sub(1);

STD::ATOMIC<T*>::OPERATOR+= , СОСТАВНОЙ ОПЕРАТОР ПРИСВАИВАНИЯ

Атомарно складывает значение аргумента со значением, хранящимся в *this, применяя стандартные правила арифметики указателей, и возвращает новое значение.

Объявление

T* operator+=(ptrdiff_t i) volatile noexcept;

T* operator+=(ptrdiff_t i) noexcept;

Результат

return this->fetch_add(i) + i;

STD::ATOMIC<T*>::OPERATOR-= , СОСТАВНОЙ ОПЕРАТОР ПРИСВАИВАНИЯ

Атомарно вычитает значение аргумента из значения, хранящегося в *this, применяя стандартные правила арифметики указателей, и возвращает новое значение.

Объявление

T* operator-=(ptrdiff_t i) volatile noexcept;

T* operator-=(ptrdiff_t i) noexcept;

Результат

return this->fetch_sub(i) - i;