Estrutura atomic

Descreve um objeto que executa operações atomic em um valor armazenado do tipo Ty.

Sintaxe

template <class Ty>
struct atomic;

Membros

Membro	Descrição
Construtor
atomic	Constrói um objeto atômico.
Operadores
atomic::operator Ty	Lê e retorna o valor armazenado. (atomic::load)
atomic::operator=	Usa um valor especificado para substituir o valor armazenado. (atomic::store)
atomic::operator++	Incrementa o valor armazenado. Usado somente por especializações integrais e de ponteiro.
atomic::operator+=	Adiciona um valor especificado ao valor armazenado. Usado somente por especializações integrais e de ponteiro.
atomic::operator--	Diminui o valor armazenado . Usado somente por especializações integrais e de ponteiro.
atomic::operator-=	Subtrai um valor especificado do valor armazenado. Usado somente por especializações integrais e de ponteiro.
atomic::operator&=	Executa um "and" (&) bit a bit em um valor especificado e no valor armazenado. Usado somente por especializações integrais.
atomic::operator|=	Executa um "or" (|) bit a bit em um valor especificado e no valor armazenado. Usado somente por especializações integrais.
atomic::operator^=	Executa um "exclusive or" (^) bit a bit em um valor especificado e no valor armazenado. Usado somente por especializações integrais.
Funções
compare_exchange_strong	Executa uma operação atomic_compare_and_exchange em this e retorna o resultado.
compare_exchange_weak	Executa uma operação weak_atomic_compare_and_exchange em this e retorna o resultado.
fetch_add	Adiciona um valor especificado ao valor armazenado.
fetch_and	Executa um "and" (&) bit a bit em um valor especificado e no valor armazenado.
fetch_or	Executa um "or" (|) bit a bit em um valor especificado e no valor armazenado.
fetch_sub	Subtrai um valor especificado do valor armazenado.
fetch_xor	Executa um "exclusive or" (^) bit a bit em um valor especificado e no valor armazenado.
is_lock_free	Especifica se operações atomic em this são livres de bloqueio. Um tipo atomic será livre de bloqueio se nenhuma operação atomic nesse tipo usar bloqueios.
load	Lê e retorna o valor armazenado.
store	Usa um valor especificado para substituir o valor armazenado.

Comentários

O tipo Ty deve ser facilmente copiado. Ou seja, usar memcpy para copiar seus bytes deve produzir um objeto Ty válido comparável ao objeto original. As funções membro compare_exchange_weak e compare_exchange_strong usam memcmp para determinar se dois valores Ty são iguais. Essas funções não usarão um operator== definido por Ty. As funções membro de atomic usam memcpy para copiar valores do tipo Ty.

Uma especialização parcial, atomic<Ty*>, existe para todos os tipos de ponteiro. A especialização permite a adição de um deslocamento para o valor do ponteiro gerenciado ou subtração de um deslocamento dele. Operações aritméticas obtêm um argumento do tipo ptrdiff_t e ajustam esse argumento de acordo com o tamanho de Ty para serem consistentes com endereço comum aritmético.

Existe uma especialização para cada tipo integral, exceto bool. Cada especialização fornece um rico conjunto de métodos para operações aritméticas e lógicas atômicas.

atomic<char>
atomic<signed char>
atomic<unsigned char>
atomic<char16_t>
atomic<char32_t>
atomic<wchar_t>
atomic<short>

atomic<unsigned short>
atomic<int>
atomic<unsigned int>
atomic<long>
atomic<unsigned long>
atomic<long long>
atomic<unsigned long long>

Especializações integrais são derivadas de tipos atomic_integral correspondentes. Por exemplo, atomic<unsigned int> é derivado de atomic_uint.

Requisitos

Cabeçalho: <atomic>

Namespace: std

atomic::atomic

Constrói um objeto atômico.

atomic();
atomic( const atomic& );
atomic( Ty Value ) noexcept;

Parâmetros

Value
Valor de inicialização.

Comentários

Objetos atômicos não podem ser copiados nem movidos.

Objetos que são instanciações de atomic<Ty> podem ser inicializados apenas pelo construtor que usa um argumento do tipo Ty, e não usando a inicialização agregada. No entanto, objetos atomic_integral só podem ser inicializados usando a inicialização agregada.

atomic<int> ai0 = ATOMIC_VAR_INIT(0);
atomic<int> ai1(0);

atomic::operator Ty

O operador do tipo especificado para o modelo, atomic<Ty>. Recupera o valor armazenado em *this.

atomic<Ty>::operator Ty() const volatile noexcept;
atomic<Ty>::operator Ty() const noexcept;

Comentários

Esse operador aplica o memory_order_seq_cst memory_order.

atomic::operator=

Armazena um valor especificado.

Ty operator=(
   Ty Value
) volatile noexcept;
Ty operator=(
   Ty Value
) noexcept;

Parâmetros

Value
Um objeto Ty.

Valor de retorno

Retorna Value.

atomic::operator++

Incrementa o valor armazenado. Usado somente por especializações integrais e de ponteiro.

Ty atomic<Ty>::operator++(int) volatile noexcept;
Ty atomic<Ty>::operator++(int) noexcept;
Ty atomic<Ty>::operator++() volatile noexcept;
Ty atomic<Ty>::operator++() noexcept;

Valor de retorno

Os dois primeiros operadores retornam o valor incrementado. Os dois últimos operadores retornam o valor antes do incremento. Os operadores usam o memory_order_seq_cst memory_order.

atomic::operator+=

Adiciona um valor especificado ao valor armazenado. Usado somente por especializações integrais e de ponteiro.

Ty atomic<Ty>::operator+=(
   Ty Value
) volatile noexcept;
Ty atomic<Ty>::operator+=(
   Ty Value
) noexcept;

Parâmetros

Value
Um valor integral ou de ponteiro.

Valor de retorno

Um objeto Ty que contém os resultados da soma.

Comentários

Esse operador usa o memory_order_seq_cst memory_order.

atomic::operator--

Diminui o valor armazenado . Usado somente por especializações integrais e de ponteiro.

Ty atomic<Ty>::operator--(int) volatile noexcept;
Ty atomic<Ty>::operator--(int) noexcept;
Ty atomic<Ty>::operator--() volatile noexcept;
Ty atomic<Ty>::operator--() noexcept;

Valor de retorno

Os dois primeiros operadores retornam o valor reduzido. Os dois últimos operadores retornam o valor antes da redução. Os operadores usam o memory_order_seq_cst memory_order.

atomic::operator-=

Subtrai um valor especificado do valor armazenado. Usado somente por especializações integrais e de ponteiro.

Ty atomic<Ty>::operator-=(
   Ty Value
) volatile noexcept;
Ty atomic<Ty>::operator-=(
   Ty Value
) noexcept;

Parâmetros

Value
Um valor integral ou de ponteiro.

Valor de retorno

Um objeto Ty que contém os resultados da subtração.

Comentários

Esse operador usa o memory_order_seq_cst memory_order.

atomic::operator&=

Executa um "and" (&) bit a bit em um valor especificado e no valor armazenado de *this. Usado somente por especializações integrais.

atomic<Ty>::operator&= (
   Ty Value
) volatile noexcept;
atomic<Ty>::operator&= (
   Ty Value
) noexcept;

Parâmetros

Value
Um valor do tipo Ty.

Valor de retorno

O resultado do "and" bit a bit (&).

Comentários

Esse operador executa uma operação de leitura-modificação-gravação para substituir o valor armazenado de *this por um bit a bit "e" (&) de Value e o valor atual armazenado em *this, dentro das restrições do memory_order_seq_cst memory_order.

atomic::operator|=

Executa um "or" (|) bit a bit em um valor especificado e no valor armazenado de *this. Usado somente por especializações integrais.

atomic<Ty>::operator|= (
   Ty Value
) volatile noexcept;
atomic<Ty>::operator|= (
   Ty Value
) noexcept;

Parâmetros

Value
Um valor do tipo Ty.

Valor de retorno

O resultado do "or" bit a bit (|).

Comentários

Esse operador executa uma operação de leitura-modificação-gravação para substituir o valor armazenado de *this por um bit a bit "ou" (|) de Value e o valor atual armazenado em *this, dentro das restrições das memory_order_seq_cst memory_order restrições.

atomic::operator^=

Executa um "exclusive or" (^) bit a bit em um valor especificado e no valor armazenado de *this. Usado somente por especializações integrais.

atomic<Ty>::operator^= (
   Ty Value
) volatile noexcept;
atomic<Ty>::operator^= (
   Ty Value
) noexcept;

Parâmetros

Value
Um valor do tipo Ty.

Valor de retorno

O resultado do "exclusive or" (^) bit a bit.

Comentários

Esse operador executa uma operação de leitura-modificação-gravação para substituir o valor armazenado de *this por um bit a bit "exclusive or" (^) de Value e o valor atual armazenado em *this, dentro das restrições das memory_order_seq_cst memory_order restrições.

atomic::compare_exchange_strong

Executa uma operação atômica de comparação e troca em *this.

bool compare_exchange_strong(
   Ty& Exp,
   Ty Value,
   memory_order Order1,
   memory_order Order2
) volatile noexcept;
bool compare_exchange_strong(
   Ty& Exp,
   Ty Value,
   memory_order Order1,
   memory_order Order2
) noexcept;
bool compare_exchange_strong(
   Ty& Exp,
   Ty Value,
   memory_order Order1 = memory_order_seq_cst
) volatile noexcept;
bool compare_exchange_strong(
   Ty& Exp,
   Ty Value,
   memory_order Order1 = memory_order_seq_cst
) noexcept;

Parâmetros

Exp
Um valor do tipo Ty.

Value
Um valor do tipo Ty.

Order1
Primeiro argumento memory_order.

Order2
Segundo argumento memory_order.

Valor de retorno

Um bool que indica o resultado da comparação de valor.

Comentários

Essa operação atômica de comparação e troca compara o valor armazenado em *this com Exp. Se os valores forem iguais, a operação substituirá o valor armazenado em *this por Value usando uma operação de leitura, alteração e gravação e aplicando as restrições de ordem de memória especificadas por Order1. Se os valores não forem iguais, a operação usará o valor armazenado em *this para substituir Exp e aplicará as restrições de ordem de memória especificadas por Order2.

Sobrecargas que não têm um segundo memory_order usam um Order2 implícito baseado no valor de Order1. Se Order1 for memory_order_acq_rel, Order2 é memory_order_acquire. Se Order1 for memory_order_release, Order2 é memory_order_relaxed. Em todos os outros casos, Order2 é igual a Order1.

Para sobrecargas que usam dois parâmetros memory_order, o valor de Order2 não poderá ser memory_order_release ou memory_order_acq_rel e não deverá ser mais forte do que o valor de Order1.

atomic::compare_exchange_weak

Executa uma operação atômica de comparação e troca fraca em *this.

bool compare_exchange_weak(
   Ty& Exp,
   Ty Value,
   memory_order Order1,
   memory_order Order2
) volatile noexcept;
bool compare_exchange_weak(
   Ty& Exp,
   Ty Value,
   memory_order Order1,
   memory_order Order2
) noexcept;
bool compare_exchange_weak(
   Ty& Exp,
   Ty Value,
   memory_order Order1 = memory_order_seq_cst
) volatile noexcept;
bool compare_exchange_weak(
   Ty& Exp,
   Ty Value,
   memory_order Order1 = memory_order_seq_cst
) noexcept;

Parâmetros

Exp
Um valor do tipo Ty.

Value
Um valor do tipo Ty.

Order1
Primeiro argumento memory_order.

Order2
Segundo argumento memory_order.

Valor de retorno

Um bool que indica o resultado da comparação de valor.

Comentários

Essa operação atômica de comparação e troca compara o valor armazenado em *this com Exp. Se os valores forem iguais, a operação substituirá o valor armazenado em *this por Value usando uma operação de leitura, alteração e gravação e aplicando as restrições de ordem de memória especificadas por Order1. Se os valores não forem iguais, a operação usará o valor armazenado em *this para substituir Exp e aplicará as restrições de ordem de memória especificadas por Order2.

Uma operação de comparar e trocar atômica fraca executará uma troca se os valores comparados forem iguais. Se os valores não forem iguais, não haverá garantia de que a operação executará uma troca.

Sobrecargas que não têm um segundo memory_order usam um Order2 implícito baseado no valor de Order1. Se Order1 for memory_order_acq_rel, Order2 é memory_order_acquire. Se Order1 for memory_order_release, Order2 é memory_order_relaxed. Em todos os outros casos, Order2 é igual a Order1.

Para sobrecargas que usam dois parâmetros memory_order, o valor de Order2 não poderá ser memory_order_release ou memory_order_acq_rel e não deverá ser mais forte do que o valor de Order1.

atomic::exchange

Usa um valor especificado para substituir o valor armazenado de *this.

Ty atomic<Ty>::exchange(
   Ty Value,
   memory_order Order = memory_order_seq_cst
) volatile noexcept;
Ty atomic<Ty>::exchange(
   Ty Value,
   memory_order Order = memory_order_seq_cst
) noexcept;

Parâmetros

Value
Um valor do tipo Ty.

Order
Um memory_order.

Valor de retorno

O valor armazenado de *this antes da troca.

Comentários

A operação executa uma operação de leitura, alteração e gravação para usar Value para substituir o valor armazenado em *this, dentro das restrições de memória especificadas por Order.

atomic::fetch_add

Busca o valor armazenado em *this e adiciona um valor especificado ao valor armazenado.

Ty atomic<Ty>::fetch_add (
   Ty Value,
   memory_order Order = memory_order_seq_cst
) volatile noexcept;
Ty atomic<Ty>::fetch_add (
   Ty Value,
   memory_order Order = memory_order_seq_cst
) noexcept;

Parâmetros

Value
Um valor do tipo Ty.

Order
Um memory_order.

Valor de retorno

Um objeto Ty que contém o valor armazenado em *this antes da adição.

Comentários

O método fetch_add executa uma operação de leitura, alteração e gravação para adicionar atomicamente Value ao valor armazenado em *this e aplica as restrições de memória especificadas por Order.

atomic::fetch_and

Executa um "and" (&) bit a bit em um valor e em um valor existente armazenado em *this.

Ty atomic<Ty>::fetch_and (
   Ty Value,
   memory_order Order = memory_order_seq_cst
) volatile noexcept;
Ty atomic<Ty>::fetch_and (
   Ty Value,
   memory_order Order = memory_order_seq_cst
) noexcept;

Parâmetros

Value
Um valor do tipo Ty.

Order
Um memory_order.

Valor de retorno

Um objeto Ty que contém o resultado do "and" bit a bit (&).

Comentários

O método fetch_and executa uma operação de leitura, alteração e gravação para substituir o valor armazenado de *this por um "and" bit a bit (&) de Value e o valor atual armazenado em *this, dentro das restrições de memória especificadas por Order.

atomic::fetch_or

Executa um "or" (|) bit a bit em um valor e em um valor existente armazenado em *this.

Ty atomic<Ty>::fetch_or (
   Ty Value,
   memory_order Order = memory_order_seq_cst
) volatile noexcept;
Ty atomic<Ty>::fetch_or (
   Ty Value,
   memory_order Order = memory_order_seq_cst
) noexcept;

Parâmetros

Value
Um valor do tipo Ty.

Order
Um memory_order.

Valor de retorno

Um objeto Ty que contém o resultado do "or" bit a bit (|).

Comentários

O método fetch_or executa uma operação de leitura, alteração e gravação para substituir o valor armazenado de *this por um "or" bit a bit (|) de Value e o valor atual armazenado em *this, dentro das restrições de memória especificadas por Order.

atomic::fetch_sub

Subtrai um valor especificado do valor armazenado.

Ty atomic<Ty>::fetch_sub (
   Ty Value,
   memory_order Order = memory_order_seq_cst
) volatile noexcept;
Ty atomic<Ty>::fetch_sub (
   Ty Value,
   memory_order Order = memory_order_seq_cst
) noexcept;

Parâmetros

Value
Um valor do tipo Ty.

Order
Um memory_order.

Valor de retorno

Um objeto Ty que contém os resultados da subtração.

Comentários

O método fetch_sub executa uma operação de leitura, alteração e gravação para subtrair atomicamente Value ao valor armazenado em *this, dentro das restrições de memória especificadas por Order.

atomic::fetch_xor

Executa um "exclusive or" (^) bit a bit em um valor e em um valor existente armazenado em *this.

Ty atomic<Ty>::fetch_xor (
   Ty Value,
   memory_order Order = memory_order_seq_cst
) volatile noexcept;
Ty atomic<Ty>::fetch_xor (
   Ty Value,
   memory_order Order = memory_order_seq_cst
) noexcept;

Parâmetros

Value
Um valor do tipo Ty.

Order
Um memory_order.

Valor de retorno

Um objeto Ty que contém o resultado do "exclusive or" bit a bit (^).

Comentários

O método fetch_xor executa uma operação de leitura, alteração e gravação para substituir o valor armazenado de *this por um "exclusive or" bit a bit (^) de Value e o valor atual armazenado em *this, e aplica as restrições de memória especificadas por Order.

atomic::is_lock_free

Especifica se operações atomic em *this são livres de bloqueio.

bool is_lock_free() const volatile noexcept;

Valor de retorno

true se operações atomic em *this estiverem livres de bloqueio; caso contrário, false.

Comentários

Um tipo atomic será livre de bloqueio se nenhuma operação atomic nesse tipo usar bloqueios.

atomic::load

Recupera o valor armazenado em *this, dentro das restrições de memória especificadas.

Ty atomic::load(
   memory_order Order = memory_order_seq_cst
) const volatile noexcept;
Ty atomic::load(
   memory_order Order = memory_order_seq_cst
) const noexcept;

Parâmetros

Order
Um memory_order. Order não pode ser memory_order_release nem memory_order_acq_rel.

Valor de retorno

O valor recuperado armazenado em *this.

atomic::store

Armazena um valor especificado.

void atomic<Ty>::store(
   Ty Value,
   memory_order Order = memory_order_seq_cst
) volatile noexcept;
void atomic<Ty>::store(
   Ty Value,
   memory_order Order = memory_order_seq_cst
) noexcept;

Parâmetros

Value
Um objeto Ty.

Order
Uma restrição memory_order.

Comentários

Essa função membro armazena atomicamente Value em *this, dentro das restrições de memória especificadas por Order.

Confira também

<atomic>
Referência de Arquivos de Cabeçalho