atomic Structure

Décrit un objet qui effectue des atomic opérations sur une valeur stockée de type Ty.

Syntaxe

template <class Ty>
struct atomic;

Membres

Notes

Le type Ty doit être copiable de manière triviale. Autrement dit, l’utilisation memcpy pour copier ses octets doit produire un objet valide Ty qui se compare à l’objet d’origine. Les compare_exchange_weak fonctions membres et compare_exchange_strong les fonctions membres permettent memcmp de déterminer si deux Ty valeurs sont égales. Ces fonctions n’utilisent pas de Ty-defined operator==. Les fonctions membres de atomic utilisent memcpy pour copier les valeurs de type Ty.

Une spécialisation partielle, atomic<Ty*>, existe pour tous les types de pointeur. La spécialisation permet d’ajouter un décalage à la valeur de pointeur gérée ou de lui soustraire un décalage. Les opérations arithmétiques prennent un argument de type ptrdiff_t et ajustent cet argument en fonction de la taille de Ty pour être cohérent avec l’arithmétique d’adresse ordinaire.

Une spécialisation existe pour chaque type intégral sauf bool. Chaque spécialisation fournit un ensemble complet de méthodes pour les opérations atomiques arithmétiques et logiques.

Les spécialisations intégrales sont dérivées des types atomic_integral correspondants. Par exemple, atomic<unsigned int> est dérivé de atomic_uint.

Spécifications

En-tête : <atomic>

Espace de noms : std

atomic::atomic

Construit un objet atomique.

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

Paramètres

Value
Valeur d’initialisation.

Notes

Les objets atomiques ne peuvent pas être copiés ou déplacés.

Les objets qui sont des instanciations de atomic<Ty> peuvent être initialisés uniquement par le constructeur qui prend un argument de type Ty et non à l’aide de l’initialisation d’agrégation. Toutefois, atomic_integral les objets peuvent être initialisés uniquement à l’aide de l’initialisation d’agrégation.

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

atomic::operator Ty

Opérateur du type spécifié dans le modèle. atomic<Ty> Récupère la valeur stockée dans *this.

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

Notes

Cet opérateur applique le memory_order_seq_cst memory_order.

atomic::operator=

Stocke une valeur spécifiée.

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

Paramètres

Value
Objet Ty.

Valeur de retour

Retourne Value.

atomic::operator++

Incrémente la valeur stockée. Utilisé uniquement par les spécialisations intégrales et de pointeur.

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

Valeur de retour

Les deux premiers opérateurs retournent la valeur incrémentée ; les deux derniers opérateurs retournent la valeur avant l’incrément. Les opérateurs utilisent le memory_order_seq_cst memory_order.

atomic::operator+=

Ajoute une valeur spécifiée à la valeur stockée. Utilisé uniquement par les spécialisations intégrales et de pointeur.

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

Paramètres

Value
Valeur intégrale ou pointeur.

Valeur de retour

Objet Ty qui contient le résultat de l’ajout.

Notes

Cet opérateur utilise le memory_order_seq_cst memory_order.

atomic::operator--

Décrémente la valeur stockée . Utilisé uniquement par les spécialisations intégrales et de pointeur.

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

Valeur de retour

Les deux premiers opérateurs retournent la valeur décrémentée ; les deux derniers opérateurs retournent la valeur avant la décrémentation. Les opérateurs utilisent le memory_order_seq_cst memory_order.

atomic::operator-=

Soustrait une valeur spécifiée de la valeur stockée. Utilisé uniquement par les spécialisations intégrales et de pointeur.

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

Paramètres

Value
Valeur intégrale ou pointeur.

Valeur de retour

Objet Ty qui contient le résultat de la soustraction.

Notes

Cet opérateur utilise le memory_order_seq_cst memory_order.

atomic::operator&=

Effectue un « and » au niveau du bit (&) sur une valeur spécifiée et la valeur stockée de *this. Utilisé uniquement par les spécialisations intégrales.

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

Paramètres

Value
Valeur de type Ty.

Valeur de retour

Résultat du « et » au niveau du bit (&).

Notes

Cet opérateur effectue une opération en lecture-modification-écriture pour remplacer la valeur stockée d’un « et » au niveau du *this bit () et Value de la valeur actuelle stockée dans *this, dans les contraintes du memory_order_seq_cst memory_order.&

atomic::operator|=

Effectue un « or » au niveau du bit (|) sur une valeur spécifiée et la valeur stockée de *this. Utilisé uniquement par les spécialisations intégrales.

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

Paramètres

Value
Valeur de type Ty.

Valeur de retour

Résultat du bit « ou » (|).

Notes

Cet opérateur effectue une opération en lecture-modification-écriture pour remplacer la valeur stockée par un « ou » au| niveau du Value *this bit et la valeur actuelle stockée dans *this, dans les contraintes des memory_order_seq_cst memory_order contraintes.

atomic::operator^=

Effectue une opération « exclusive » au niveau du bit (^) sur une valeur spécifiée et la valeur stockée de *this. Utilisé uniquement par les spécialisations intégrales.

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

Paramètres

Value
Valeur de type Ty.

Valeur de retour

Résultat du bit « exclusif ou » (^).

Notes

Cet opérateur effectue une opération en lecture-modification-écriture pour remplacer la valeur stockée par *this un bit « exclusif ou » (^) et Value la valeur actuelle stockée dans *this, dans les contraintes des memory_order_seq_cst memory_order contraintes.

atomic::compare_exchange_strong

Effectue une opération de comparaison atomique et d’échange sur *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;

Paramètres

Exp
Valeur de type Ty.

Value
Valeur de type Ty.

Order1
Premier memory_order argument.

Order2
Deuxième argument memory_order.

Valeur de retour

bool qui indique le résultat de la comparaison de valeurs.

Notes

Cette opération atomique de comparaison et d’échange compare la valeur stockée avec *this Exp. Si les valeurs sont égales, l’opération remplace la valeur stockée par *this Value une opération en lecture-modification-écriture et l’application des contraintes d’ordre de mémoire spécifiées par Order1. Si les valeurs ne sont pas égales, l’opération utilise la valeur stockée pour *this remplacer Exp et applique les contraintes d’ordre de mémoire spécifiées par Order2.

Les surcharges qui n’ont pas de seconde memory_order utilisent un implicite Order2 basé sur la valeur de Order1. Si Order1 est memory_order_acq_rel, Order2 est memory_order_acquire. Si Order1 est memory_order_release, Order2 est memory_order_relaxed. Dans tous les autres cas, Order2 est égal à Order1.

Pour les surcharges qui prennent deux memory_order paramètres, la valeur de Order2 ne doit pas être memory_order_release ou memory_order_acq_relne doit pas être plus forte que la valeur de Order1.

atomic::compare_exchange_weak

Effectue une opération de comparaison atomique faible et d’échange sur *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;

Paramètres

Exp
Valeur de type Ty.

Value
Valeur de type Ty.

Order1
Premier memory_order argument.

Order2
Deuxième argument memory_order.

Valeur de retour

bool qui indique le résultat de la comparaison de valeurs.

Notes

Cette opération atomique de comparaison et d’échange compare la valeur stockée avec *this Exp. Si les valeurs sont égales, l’opération remplace la valeur stockée par *this Value une opération en lecture-modification-écriture et l’application des contraintes d’ordre de mémoire spécifiées par Order1. Si les valeurs ne sont pas égales, l’opération utilise la valeur stockée pour *this remplacer Exp et applique les contraintes d’ordre de mémoire spécifiées par Order2.

Une opération atomique faible de comparaison et d’échange effectue un échange si les valeurs comparées sont égales. Si les valeurs ne sont pas égales, l’opération n’est pas garantie d’effectuer un échange.

Les surcharges qui n’ont pas de seconde memory_order utilisent un implicite Order2 basé sur la valeur de Order1. Si Order1 est memory_order_acq_rel, Order2 est memory_order_acquire. Si Order1 est memory_order_release, Order2 est memory_order_relaxed. Dans tous les autres cas, Order2 est égal à Order1.

Pour les surcharges qui prennent deux memory_order paramètres, la valeur de Order2 ne doit pas être memory_order_release ou memory_order_acq_relne doit pas être plus forte que la valeur de Order1.

atomic::exchange

Utilise une valeur spécifiée pour remplacer la valeur stockée 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;

Paramètres

Value
Valeur de type Ty.

Order
Un memory_order.

Valeur de retour

Valeur stockée de *this avant l’échange.

Notes

Cette opération effectue une opération en lecture-modification-écriture à utiliser Value pour remplacer la valeur stockée dans *this, dans les contraintes de mémoire spécifiées par Order.

atomic::fetch_add

Récupère la valeur stockée, *thispuis ajoute une valeur spécifiée à la valeur stockée.

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;

Paramètres

Value
Valeur de type Ty.

Order
Un memory_order.

Valeur de retour

Objet Ty qui contient la valeur stockée avant *this l’ajout.

Notes

La fetch_add méthode effectue une opération en lecture-modification-écriture pour ajouter Value atomiquement à la valeur stockée dans *this, et applique les contraintes de mémoire spécifiées par Order.

atomic::fetch_and

Effectue un « and » au niveau du bit (&) sur une valeur et une valeur existante qui est stockée dans *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;

Paramètres

Value
Valeur de type Ty.

Order
Un memory_order.

Valeur de retour

Objet Ty qui contient le résultat du bit « and » (&).

Notes

La fetch_and méthode effectue une opération en lecture-modification-écriture pour remplacer la valeur stockée par *this un bit « and » (&) et Value la valeur actuelle stockée dans *this, dans les contraintes de mémoire spécifiées par Order.

atomic::fetch_or

Effectue un « or » au niveau du bit (|) sur une valeur et une valeur existante qui est stockée dans *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;

Paramètres

Value
Valeur de type Ty.

Order
Un memory_order.

Valeur de retour

Objet Ty qui contient le résultat du bit « ou » (|).

Notes

La fetch_or méthode effectue une opération en lecture-modification-écriture pour remplacer la valeur stockée par *this un bit « ou » (|) et Value la valeur actuelle stockée dans *this, dans les contraintes de mémoire spécifiées par Order.

atomic::fetch_sub

Soustrait une valeur spécifiée de la valeur stockée.

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;

Paramètres

Value
Valeur de type Ty.

Order
Un memory_order.

Valeur de retour

Objet Ty qui contient le résultat de la soustraction.

Notes

La fetch_sub méthode effectue une opération en lecture-modification-écriture pour soustraire Value atomiquement la valeur stockée dans *this, dans les contraintes de mémoire spécifiées par Order.

atomic::fetch_xor

Exécute un bit « exclusif ou » (^) sur une valeur et une valeur existante qui est stockée dans *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;

Paramètres

Value
Valeur de type Ty.

Order
Un memory_order.

Valeur de retour

Objet Ty qui contient le résultat du bit « exclusif ou » (^).

Notes

La fetch_xor méthode effectue une opération en lecture-modification-écriture pour remplacer la valeur stockée par *this un bit « exclusif ou » (^) et Value la valeur actuelle stockée dans *this, et applique les contraintes de mémoire spécifiées par Order.

atomic::is_lock_free

Spécifie si atomic les opérations sur *this sont sans verrou.

bool is_lock_free() const volatile noexcept;

Valeur de retour

true si atomic les opérations sont libres de *this verrouillage ; sinon, false.

Notes

Un atomic type est libre si aucune opération sur ce type n’utilise atomic des verrous.

atomic::load

Récupère la valeur stockée dans *this, dans les contraintes de mémoire spécifiées.

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;

Paramètres

Order
memory_order. Order ne doit pas être memory_order_release ou memory_order_acq_rel.

Valeur de retour

Valeur récupérée stockée dans *this.

atomic::store

Stocke une valeur spécifiée.

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;

Paramètres

Value
Objet Ty.

Order
Contrainte memory_order .

Notes

Cette fonction membre stocke Value *thisatomiquement dans , dans les contraintes de mémoire spécifiées par Order.

Voir aussi

<atomic>
Informations de référence sur les fichiers d’en-tête