`atomic` Struttura

Articolo
10/12/2023

Descrive un oggetto che esegue atomic operazioni su un valore archiviato di tipo Ty.

Sintassi

template <class Ty>
struct atomic;

Membri

Membro	Descrizione
Costruttore
`atomic`	Costruisce un oggetto atomico.
Operatori
`atomic::operator Ty`	Legge e restituisce il valore archiviato. (`atomic::load`)
`atomic::operator=`	Usa un valore specificato per sostituire il valore archiviato. (`atomic::store`)
`atomic::operator++`	Incrementa il valore archiviato. Usato solo da specializzazioni integrali e dei puntatori.
`atomic::operator+=`	Aggiunge un valore specificato al valore archiviato. Usato solo da specializzazioni integrali e dei puntatori.
`atomic::operator--`	Decrementa il valore archiviato . Usato solo da specializzazioni integrali e dei puntatori.
`atomic::operator-=`	Sottrae un valore specificato da un valore archiviato. Usato solo da specializzazioni integrali e dei puntatori.
`atomic::operator&=`	Esegue un bit per bit "and" (`&`) su un valore specificato e sul valore archiviato. Usato solo da specializzazioni integrali.
`atomic::operator\|=`	Esegue un "or" bit per bit (`\|`) su un valore specificato e sul valore archiviato. Usato solo da specializzazioni integrali.
`atomic::operator^=`	Esegue un "esclusivo o" bit per bit (`^`) su un valore specificato e sul valore archiviato. Usato solo da specializzazioni integrali.
Funzioni
`compare_exchange_strong`	Esegue un'operazione `atomic_compare_and_exchange` in `this` e restituisce il risultato.
`compare_exchange_weak`	Esegue un'operazione `weak_atomic_compare_and_exchange` in `this` e restituisce il risultato.
`fetch_add`	Aggiunge un valore specificato al valore archiviato.
`fetch_and`	Esegue un bit per bit "and" (`&`) su un valore specificato e sul valore archiviato.
`fetch_or`	Esegue un "or" bit per bit (`\|`) su un valore specificato e sul valore archiviato.
`fetch_sub`	Sottrae un valore specificato da un valore archiviato.
`fetch_xor`	Esegue un "esclusivo o" bit per bit (`^`) su un valore specificato e sul valore archiviato.
`is_lock_free`	Specifica se `atomic` le operazioni su `this` sono libere dal blocco. Un `atomic` tipo è privo di blocchi se nessuna `atomic` operazione su quel tipo usa blocchi.
`load`	Legge e restituisce il valore archiviato.
`store`	Usa un valore specificato per sostituire il valore archiviato.

Osservazioni:

Il tipo Ty deve essere facilmente copiabile. Ovvero, l'utilizzo memcpy di per copiare i byte deve produrre un oggetto valido Ty che confronta uguale all'oggetto originale. Le compare_exchange_weak funzioni membro e compare_exchange_strong usano memcmp per determinare se due Ty valori sono uguali. Queste funzioni non useranno un oggetto Tydefinito da operator==. Le funzioni membro di atomic usano memcpy per copiare i valori di tipo Ty.

Per tutti i tipi di puntatore è disponibile una specializzazione parziale atomic<Ty*>. La specializzazione consente l'aggiunta o la sottrazione di un offset dal valore del puntatore gestito. Le operazioni aritmetiche accettano un argomento di tipo ptrdiff_t e modificano l'argomento in base alla dimensione di Ty per coerenza con l'aritmetica di indirizzo ordinaria.

È disponibile una specializzazione per ogni tipo integrale, ad eccezione di bool. Ogni specializzazione offre un set di metodi per le operazioni logiche e di aritmetica atomica.

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>

Le specializzazioni integrali sono derivate dai tipi atomic_integral corrispondenti. Ad esempio, atomic<unsigned int> è derivato da atomic_uint.

Requisiti

Intestazione: <atomic>

Spazio dei nomi: std

`atomic::atomic`

Costruisce un oggetto atomico.

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

Parametri

Value
Valore di inizializzazione.

Osservazioni:

Gli oggetti atomici non possono essere copiati o spostati.

Gli oggetti di atomic<Ty> cui è stata creata un'istanza possono essere inizializzati solo dal costruttore che accetta un argomento di tipo Ty e non tramite l'inizializzazione di aggregazione. Tuttavia, atomic_integral gli oggetti possono essere inizializzati solo usando l'inizializzazione aggregata.

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

`atomic::operator Ty`

Operatore per il tipo specificato nel modello, atomic<Ty>. Recupera il valore archiviato in *this.

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

Osservazioni:

Questo operatore applica .memory_order_seq_cst memory_order

`atomic::operator=`

Archivia un valore specificato.

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

Parametri

Value
Oggetto Ty.

Valore restituito

Restituisce Value.

`atomic::operator++`

Incrementa il valore archiviato. Usato solo da specializzazioni integrali e dei puntatori.

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

Valore restituito

I primi due operatori restituiscono il valore incrementato; gli ultimi due operatori restituiscono il valore prima dell'incremento. Gli operatori usano .memory_order_seq_cst memory_order

`atomic::operator+=`

Aggiunge un valore specificato al valore archiviato. Usato solo da specializzazioni integrali e dei puntatori.

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

Parametri

Value
Valore integrale o puntatore.

Valore restituito

Oggetto Ty contenente il risultato dell'addizione.

Osservazioni:

Questo operatore usa .memory_order_seq_cst memory_order

`atomic::operator--`

Decrementa il valore archiviato . Usato solo da specializzazioni integrali e dei puntatori.

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

Valore restituito

I primi due operatori restituiscono il valore decrementato; gli ultimi due operatori restituiscono il valore prima del decremento. Gli operatori usano .memory_order_seq_cst memory_order

`atomic::operator-=`

Sottrae un valore specificato da un valore archiviato. Usato solo da specializzazioni integrali e dei puntatori.

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

Parametri

Value
Valore integrale o puntatore.

Valore restituito

Oggetto Ty che contiene il risultato della sottrazione.

Osservazioni:

Questo operatore usa .memory_order_seq_cst memory_order

`atomic::operator&=`

Esegue un "and" bit per bit (&) su un valore specificato e il valore archiviato di *this. Usato solo da specializzazioni integrali.

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

Parametri

Value
Valore di tipo Ty.

Valore restituito

Risultato del bit per bit "and" (&).

Osservazioni:

Questo operatore esegue un'operazione di lettura-modifica/scrittura per sostituire il valore archiviato di *this con un valore bit per bit "and" (&) e Value il valore corrente archiviato in *this, all'interno dei vincoli di memory_order_seq_cst memory_order.

`atomic::operator|=`

Esegue un "or" bit per bit (|) su un valore specificato e il valore archiviato di *this. Usato solo da specializzazioni integrali.

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

Parametri

Value
Valore di tipo Ty.

Valore restituito

Risultato del bit per bit "or" (|).

Osservazioni:

Questo operatore esegue un'operazione di lettura-modifica/scrittura per sostituire il valore archiviato di *this con un "or"| bit per bit () di Value e il valore corrente archiviato in *this, all'interno dei vincoli dei memory_order_seq_cst memory_order vincoli.

`atomic::operator^=`

Esegue un "esclusivo o" bit per bit (^) su un valore specificato e il valore archiviato di *this. Usato solo da specializzazioni integrali.

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

Parametri

Value
Valore di tipo Ty.

Valore restituito

Risultato del bit per bit "esclusivo o" (^).

Osservazioni:

Questo operatore esegue un'operazione di lettura-modifica/scrittura per sostituire il valore archiviato di *this con un bit per bit "esclusivo o" (^) di Value e il valore corrente archiviato in *this, all'interno dei vincoli dei memory_order_seq_cst memory_order vincoli.

`atomic::compare_exchange_strong`

Esegue un'operazione di confronto e scambio atomico su *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;

Parametri

Exp
Valore di tipo Ty.

Value
Valore di tipo Ty.

Order1
Primo memory_order argomento.

Order2
Secondo argomento memory_order.

Valore restituito

Valore bool che indica il risultato del confronto del valore.

Osservazioni:

Questa operazione di confronto e scambio atomico confronta il valore archiviato in *this con Exp. Se i valori sono uguali, l'operazione sostituisce il valore archiviato in *this con Value usando un'operazione di lettura-modifica/scrittura e applicando i vincoli dell'ordine di memoria specificati da Order1. Se i valori non sono uguali, l'operazione usa il valore archiviato in *this per sostituire Exp e applica i vincoli dell'ordine di memoria specificati da Order2.

Gli overload che non hanno un secondo memory_order usano un implicito Order2 basato sul valore di Order1. Se Order1 è memory_order_acq_rel, Order2 è memory_order_acquire. Se Order1 è memory_order_release, Order2 è memory_order_relaxed. In tutti gli altri casi, Order2 è uguale a Order1.

Per gli overload che accettano due memory_order parametri, il valore di Order2 non deve essere memory_order_release o memory_order_acq_rele non deve essere più forte del valore di Order1.

`atomic::compare_exchange_weak`

Esegue un'operazione di confronto atomico debole e scambio su *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;

Parametri

Exp
Valore di tipo Ty.

Value
Valore di tipo Ty.

Order1
Primo memory_order argomento.

Order2
Secondo argomento memory_order.

Valore restituito

Valore bool che indica il risultato del confronto del valore.

Osservazioni:

Un'operazione di confronto e scambio atomico debole esegue uno scambio se i valori confrontati sono uguali. Se i valori non sono uguali, non è garantito che l'operazione esegua uno scambio.

`atomic::exchange`

Usa un valore specificato per sostituire il valore archiviato di *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;

Parametri

Value
Valore di tipo Ty.

Order
Un oggetto memory_order.

Valore restituito

Valore memorizzato di *this prima dello scambio.

Osservazioni:

Questa operazione esegue un'operazione di lettura-modifica/scrittura da usare Value per sostituire il valore archiviato in *this, all'interno dei vincoli di memoria specificati da Order.

`atomic::fetch_add`

Recupera il valore archiviato in *thise quindi aggiunge un valore specificato al valore archiviato.

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;

Parametri

Value
Valore di tipo Ty.

Order
Un oggetto memory_order.

Valore restituito

Oggetto Ty che contiene il valore archiviato in *this prima dell'aggiunta.

Osservazioni:

Il fetch_add metodo esegue un'operazione di lettura-modifica/scrittura per aggiungere Value in modo atomico al valore archiviato in *thise applica i vincoli di memoria specificati da Order.

`atomic::fetch_and`

Esegue un "and" bit per bit (&) su un valore e un valore esistente archiviato in *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;

Parametri

Value
Valore di tipo Ty.

Order
Un oggetto memory_order.

Valore restituito

Oggetto Ty che contiene il risultato del bit per bit "and" (&).

Osservazioni:

Il fetch_and metodo esegue un'operazione di lettura-modifica/scrittura per sostituire il valore archiviato di con un "and"& bit per bit () e il valore corrente archiviato in *this, all'interno dei vincoli di *this Value memoria specificati da Order.

`atomic::fetch_or`

Esegue un "or" bit per bit (|) su un valore e un valore esistente archiviato in *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;

Parametri

Value
Valore di tipo Ty.

Order
Un oggetto memory_order.

Valore restituito

Oggetto Ty che contiene il risultato del bit per bit "o" (|).

Osservazioni:

Il fetch_or metodo esegue un'operazione di lettura-modifica/scrittura per sostituire il valore archiviato di con un "or"| bit per bit () di e il valore corrente archiviato in *this, all'interno dei vincoli di *this Value memoria specificati da Order.

`atomic::fetch_sub`

Sottrae un valore specificato da un valore archiviato.

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;

Parametri

Value
Valore di tipo Ty.

Order
Un oggetto memory_order.

Valore restituito

Oggetto Ty che contiene il risultato della sottrazione.

Osservazioni:

Il fetch_sub metodo esegue un'operazione di lettura-modifica/scrittura per sottrarre Value in modo atomico dal valore archiviato in *this, all'interno dei vincoli di memoria specificati da Order.

`atomic::fetch_xor`

Esegue un "esclusivo" bit per bit (^) su un valore e un valore esistente archiviato in *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;

Parametri

Value
Valore di tipo Ty.

Order
Un oggetto memory_order.

Valore restituito

Oggetto Ty che contiene il risultato del bit per bit "esclusivo o" (^).

Osservazioni:

Il fetch_xor metodo esegue un'operazione di lettura-modifica/scrittura per sostituire il valore archiviato di con un bit per bit "esclusivo o" (^) di e il valore corrente archiviato in *thise applica i vincoli di *this Value memoria specificati da Order.

`atomic::is_lock_free`

Specifica se atomic le operazioni su *this sono libere dal blocco.

bool is_lock_free() const volatile noexcept;

Valore restituito

true se atomic le operazioni su *this sono libere da blocchi; in caso contrario, false.

Osservazioni:

Un atomic tipo è privo di blocchi se nessuna atomic operazione su quel tipo usa blocchi.

`atomic::load`

Recupera il valore archiviato in *this, all'interno dei vincoli di memoria specificati.

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;

Parametri

Order
Un oggetto memory_order. Order non deve essere memory_order_release o memory_order_acq_rel.

Valore restituito

Valore recuperato archiviato in *this.

`atomic::store`

Archivia un valore specificato.

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;

Parametri

Value
Oggetto Ty.

Order
Vincolo memory_order .

Osservazioni:

Questa funzione membro archivia Value in modo atomico in *this, all'interno dei vincoli di memoria specificati da Order.

Vedi anche

<atomic>
Riferimento file di intestazione

Condividi tramite

atomic Struttura

Sintassi

Membri

Osservazioni:

Requisiti

atomic::atomic

Parametri

Osservazioni:

atomic::operator Ty

Osservazioni:

atomic::operator=

Parametri

Valore restituito

atomic::operator++

Valore restituito

atomic::operator+=

Parametri

Valore restituito

Osservazioni:

atomic::operator--

Valore restituito

atomic::operator-=

Parametri

Valore restituito

Osservazioni:

atomic::operator&=

Parametri

Valore restituito

Osservazioni:

atomic::operator|=

Parametri

Valore restituito

Osservazioni:

atomic::operator^=

Parametri

Valore restituito

Osservazioni:

atomic::compare_exchange_strong

Parametri

Valore restituito

Osservazioni:

atomic::compare_exchange_weak

Parametri

Valore restituito

Osservazioni:

atomic::exchange

Parametri

Valore restituito

Osservazioni:

atomic::fetch_add

Parametri

Valore restituito

Osservazioni:

atomic::fetch_and

Parametri

Valore restituito

Osservazioni:

atomic::fetch_or

Parametri

Valore restituito

Osservazioni:

atomic::fetch_sub

Parametri

Valore restituito

Osservazioni:

atomic::fetch_xor

Parametri

Valore restituito

Osservazioni:

atomic::is_lock_free

Valore restituito

Osservazioni:

atomic::load

Parametri

Valore restituito

atomic::store

Parametri

Osservazioni:

Vedi anche

`atomic` Struttura

`atomic::atomic`

`atomic::operator Ty`

`atomic::operator=`

`atomic::operator++`

`atomic::operator+=`

`atomic::operator--`

`atomic::operator-=`

`atomic::operator&=`

`atomic::operator|=`

`atomic::operator^=`

`atomic::compare_exchange_strong`

`atomic::compare_exchange_weak`

`atomic::exchange`

`atomic::fetch_add`

`atomic::fetch_and`

`atomic::fetch_or`

`atomic::fetch_sub`

`atomic::fetch_xor`

`atomic::is_lock_free`

`atomic::load`

`atomic::store`