Partager via

fonctions<atomic>

L’en-tête <atomic> fournit les fonctions suivantes :

atomic_compare_exchange_strong

Effectue une opération atomique de comparaison et d’échange.

template <class Ty>
inline bool atomic_compare_exchange_strong(
    volatile atomic<Ty>* Atom,
    Ty* Exp,
    Value) noexcept;

template <class Ty>
inline bool atomic_compare_exchange_strong(
    atomic<Ty>* Atom,
    Ty* Exp,
    Ty Value) noexcept;

Paramètres

Atom
Pointeur vers un objet atomic qui stocke une valeur de type Ty.

Exp
Pointeur vers une valeur de type Ty.

Value
Valeur de type Ty.

Valeur de retour

true si les valeurs sont égales, sinon false.

Notes

Cette méthode effectue une opération de comparaison atomique et d’échange à l’aide d’arguments implicites memory_order.memory_order_seq_cst . Pour plus d’informations, consultez atomic_compare_exchange_strong_explicit.

atomic_compare_exchange_strong_explicit

Effectue une atomic compare and exchange opération.

template <class T>
inline bool atomic_compare_exchange_strong_explicit(
    volatile atomic<Ty>* Atom,
    Ty* Exp,
    Ty Value,
    memory_order Order1,
    memory_order Order2) noexcept;

template <class Ty>
inline bool atomic_compare_exchange_strong_explicit(
    atomic<Ty>* Atom,
    Ty* Exp,
    Ty Value,
    memory_order Order1,
    memory_order Order2) noexcept;

Paramètres

Atom
Pointeur vers un objet atomic qui stocke une valeur de type Ty.

Exp
Pointeur vers une valeur de type Ty.

Value
Valeur de type Ty.

Order1
Premier memory_order argument.

Order2
Deuxième argument memory_order. La valeur de Order2 ne peut pas être memory_order_release ou memory_order_acq_rel, elle ne peut pas être supérieure à la valeur de Order1.

Valeur de retour

true si les valeurs sont égales, sinon false.

Notes

Une atomic compare and exchange operation comparaison de la valeur stockée dans l’objet pointé par Atom rapport à la valeur pointée par Exp. Si les valeurs sont égales, la valeur stockée dans l’objet pointé par Atom est remplacée Value par une opération en lecture-modification-écriture et en appliquant les contraintes d’ordre de mémoire spécifiées par Order1. Si les valeurs ne sont pas égales, l’opération remplace la valeur pointée par Exp la valeur stockée dans l’objet pointé vers Atom et applique les contraintes d’ordre de mémoire spécifiées par Order2.

atomic_compare_exchange_weak

Effectue une opération atomique faible de comparaison et d’échange.

template <class Ty>
inline bool atomic_compare_exchange_strong(
    volatile atomic<Ty>* Atom,
    Ty* Exp,
    Ty Value) noexcept;

template <class Ty>
inline bool atomic_compare_exchange_strong(
    atomic<Ty>* Atom,
    Ty* Exp,
    Ty Value) noexcept;

Paramètres

Atom
Pointeur vers un objet atomic qui stocke une valeur de type Ty.

Exp
Pointeur vers une valeur de type Ty.

Value
Valeur de type Ty.

Valeur de retour

true si les valeurs sont égales, sinon false.

Notes

Cette méthode effectue une opération de comparaison atomique et d’échange faible qui a des arguments implicitesmemory_order.memory_order_seq_cst. Pour plus d’informations, consultez atomic_compare_exchange_weak_explicit.

atomic_compare_exchange_weak_explicit

Effectue une opération atomique faible de comparaison et d’échange.

template <class Ty>
inline bool atomic_compare_exchange_weak_explicit(
    volatile atomic<Ty>* Atom,
    Ty* Exp,
    Ty Value,
    memory_order Order1,
    memory_order Order2) noexcept;

template <class Ty>
inline bool atomic_compare_exchange_weak_explicit(
    atomic<Ty>* Atom,
    Ty* Exp,
    Ty Value,
    memory_order Order1,
    memory_order Order2) noexcept;

Paramètres

Atom
Pointeur vers un objet atomic qui stocke une valeur de type Ty.

Exp
Pointeur vers une valeur de type Ty.

Value
Valeur de type Ty.

Order1
Premier memory_order argument.

Order2
Deuxième argument memory_order. La valeur de Order2 ne peut pas être memory_order_release ou memory_order_acq_rel, elle ne peut pas être non plus supérieure à la valeur de Order1.

Valeur de retour

true si les valeurs sont égales, sinon false.

Notes

Les saveurs fortes et faibles d’une atomic compare and exchange operation garantie qu’elles ne stockent pas la nouvelle valeur si les valeurs attendues et actuelles ne sont pas égales. La saveur forte garantit qu’elle stockera la nouvelle valeur si les valeurs attendues et actuelles sont égales. La saveur faible peut parfois retourner false et ne pas stocker la nouvelle valeur même si les valeurs actuelles et attendues sont égales. En d’autres termes, la fonction retourne false, mais un examen ultérieur de la valeur attendue peut révéler qu’elle n’a pas changé, et doit donc avoir comparé à égal.

atomic_exchange

Utilise Value pour remplacer la valeur stockée de Atom.

template <class T>
inline Ty atomic_exchange(volatile atomic<Ty>* _Atom, Ty Value) noexcept;

template <class Ty>
inline T atomic_exchange(atomic<Ty>* Atom, Ty Value) noexcept;

Paramètres

Atom
Pointeur vers un objet atomic qui stocke une valeur de type Ty.

Value
Valeur de type Ty.

Valeur de retour

Valeur stockée de Atom avant l’échange.

Notes

La atomic_exchange fonction effectue une opération en lecture-modification-écriture pour échanger la valeur stockée avec AtomValue, à l’aide du memory_order.memory_order_seq_cst.

atomic_exchange_explicit

Remplace la valeur stockée de Atom par Value.

template <class Ty>
inline Ty atomic_exchange_explicit(
    volatile atomic<Ty>* Atom,
    Ty Value,
    memory_order Order) noexcept;

template <class Ty>
inline Ty atomic_exchange_explicit(
    atomic<Ty>* Atom,
    Ty Value,
    memory_order Order) noexcept;

Paramètres

Atom
Pointeur vers un objet atomic qui stocke une valeur de type Ty.

Value
Valeur de type Ty.

Order
Un memory_order.

Valeur de retour

Valeur stockée de Atom avant l’échange.

Notes

La atomic_exchange_explicit fonction effectue une opération en lecture-modification-écriture pour échanger la valeur stockée avec AtomValue, dans les contraintes de mémoire spécifiées par Order.

atomic_fetch_add

Ajoute une valeur à une valeur existante stockée dans un objet atomic.

template <class T>
T* atomic_fetch_add(volatile atomic<T*>* Atom, ptrdiff_t Value) noexcept;
template <class T>
T* atomic_fetch_add(atomic<T*>* Atom, ptrdiff_t Value) noexcept;

Paramètres

Atom
Pointeur vers un objet atomic qui stocke un pointeur de type T.

Value
Valeur de type ptrdiff_t.

Valeur de retour

Valeur du pointeur contenu par l’objet atomic immédiatement avant l’exécution de l’opération.

Notes

La atomic_fetch_add fonction effectue une opération en lecture-modification-écriture pour ajouter Value atomiquement à la valeur stockée dans Atom, à l’aide de la memory_order.memory_order_seq_cst contrainte.

Quand le type atomique est atomic_address, Value a le type ptrdiff_t et l’opération traite le pointeur stocké comme un char *.

Cette opération est également surchargée pour les types intégraux :

integral atomic_fetch_add(volatile atomic-integral* Atom, integral Value) noexcept;

integral atomic_fetch_add(atomic-integral* Atom, integral Value) noexcept;

atomic_fetch_add_explicit

Ajoute une valeur à une valeur existante stockée dans un objet atomic.

template <class T>
T* atomic_fetch_add_explicit(
    volatile atomic<T*>* Atom,
    ptrdiff_t Value,
    memory_order Order) noexcept;

template <class T>
T* atomic_fetch_add_explicit(
    atomic<T*>* Atom,
    ptrdiff_t Value,
    memory_order Order) noexcept;

Paramètres

Atom
Pointeur vers un objet atomic qui stocke un pointeur de type T.

Value
Valeur de type ptrdiff_t.

Valeur de retour

Valeur du pointeur contenu par l’objet atomic immédiatement avant l’exécution de l’opération.

Notes

La atomic_fetch_add_explicit fonction effectue une opération en lecture-modification-écriture pour ajouter Value atomiquement à la valeur stockée dans Atom, dans les memory_order contraintes spécifiées par Order.

Quand le type atomique est atomic_address, Value a le type ptrdiff_t et l’opération traite le pointeur stocké comme un char *.

Cette opération est également surchargée pour les types intégraux :

integral atomic_fetch_add_explicit(
    volatile atomic-integral* Atom,
    integral Value,
    memory_order Order) noexcept;

integral atomic_fetch_add_explicit(
    atomic-integral* Atom,
    integral Value,
    memory_order Order) noexcept;

atomic_fetch_and

Effectue une opération & au niveau du bit sur une valeur et une valeur existante stockée dans un objet atomic.

template <class T>
inline T atomic_fetch_and(volatile atomic<T>* Atom, T Value) noexcept;
template <class T>
inline T atomic_fetch_and(volatile atomic<T>* Atom, T Value) noexcept;

Paramètres

Atom
Pointeur vers un objet atomic qui stocke une valeur de type T.

Value
Valeur de type T.

Valeur de retour

Valeur contenue par l’objet atomic immédiatement avant l’exécution de l’opération.

Notes

La atomic_fetch_and fonction effectue une opération de lecture-modification-écriture pour remplacer la valeur stockée par Atom un bit au niveau & du bit et la valeur actuelle stockée dans , à Valuel’aide de Atom la memory_order.memory_order_seq_cst contrainte.

atomic_fetch_and_explicit

Effectue une opération & au niveau du bit sur une valeur et une valeur existante stockée dans un objet atomic.

template <class T>
inline T atomic_fetch_and_explicit(
    volatile atomic<T>* Atom,
    T Value,
    memory_order Order) noexcept;

template <class T>
inline T atomic_fetch_and_explicit(
    volatile atomic<T>* Atom,
    T Value,
    memory_order Order) noexcept;

Paramètres

Atom
Pointeur vers un objet atomic qui stocke une valeur de type T.

Value
Valeur de type T.

Order
Un memory_order.

Valeur de retour

Valeur contenue par l’objet atomic immédiatement avant l’exécution de l’opération.

Notes

La atomic_fetch_and_explicit fonction effectue une opération en lecture-modification-écriture pour remplacer la valeur stockée par Atom un bit au niveau & du Value bit et la valeur actuelle stockée dans Atom, dans les contraintes de mémoire spécifiées par Order.

atomic_fetch_or

Effectue une opération or au niveau du bit sur une valeur et une valeur existante stockée dans un objet atomic.

template <class T>
inline T atomic_fetch_or (volatile atomic<T>* Atom, T Value) noexcept;
template <class T>
inline T atomic_fetch_or (volatile atomic<T>* Atom, T Value) noexcept;

Paramètres

Atom
Pointeur vers un objet atomic qui stocke une valeur de type T.

Value
Valeur de type T.

Valeur de retour

Valeur contenue par l’objet atomic immédiatement avant l’exécution de l’opération.

Notes

La atomic_fetch_or fonction effectue une opération en lecture-modification-écriture pour remplacer la valeur stockée par Atom un bit au niveau or du Value bit et la valeur actuelle qui est stockée dans Atom, à l’aide du memory_order.memory_order_seq_cst.

atomic_fetch_or_explicit

Effectue une opération or au niveau du bit sur une valeur et une valeur existante stockée dans un objet atomic.

template <class T>
inline T atomic_fetch_or_explicit(
    volatile atomic<T>* Atom,
    T Value,
    memory_order Order) noexcept;

template <class T>
inline T atomic_fetch_or_explicit(
    volatile atomic<T>* Atom,
    T Value,
    memory_order Order) noexcept;

Paramètres

Atom
Pointeur vers un objet atomic qui stocke une valeur de type T.

Value
Valeur de type T.

Order
Un memory_order.

Valeur de retour

Valeur contenue par l’objet atomic immédiatement avant l’exécution de l’opération.

Notes

La atomic_fetch_or_explicit fonction effectue une opération en lecture-modification-écriture pour remplacer la valeur stockée par Atom un bit au niveau or du Value bit et la valeur actuelle stockée dans Atom, dans les memory_order contraintes spécifiées par Order.

atomic_fetch_sub

Soustrait une valeur d’une valeur existante stockée dans un objet atomic.

template <class T>
T* atomic_fetch_sub(
    volatile atomic<T*>* Atom,
    ptrdiff_t Value) noexcept;

template <class T>
T* atomic_fetch_sub(
    atomic<T*>* Atom,
    ptrdiff_t Value) noexcept;

Paramètres

Atom
Pointeur vers un objet atomic qui stocke un pointeur de type T.

Value
Valeur de type ptrdiff_t.

Valeur de retour

Valeur du pointeur contenu par l’objet atomic immédiatement avant l’exécution de l’opération.

Notes

La atomic_fetch_sub fonction effectue une opération de lecture-modification-écriture pour soustraire Value atomiquement la valeur stockée dans Atom, à l’aide de la memory_order.memory_order_seq_cst contrainte.

Quand le type atomique est atomic_address, Value a le type ptrdiff_t et l’opération traite le pointeur stocké comme un char *.

Cette opération est également surchargée pour les types intégraux :

integral atomic_fetch_sub(volatile atomic-integral* Atom, integral Value) noexcept;
integral atomic_fetch_sub(atomic-integral* Atom, integral Value) noexcept;

atomic_fetch_sub_explicit

Soustrait une valeur d’une valeur existante stockée dans un objet atomic.

template <class T>
T* atomic_fetch_sub_explicit(
    volatile atomic<T*>* Atom,
    ptrdiff_t Value,
    memory_order Order) noexcept;

template <class T>
T* atomic_fetch_sub_explicit(
    atomic<T*>* Atom,
    ptrdiff_t Value, memory_order Order) noexcept;

Paramètres

Atom
Pointeur vers un objet atomic qui stocke un pointeur de type T.

Value
Valeur de type ptrdiff_t.

Valeur de retour

Valeur du pointeur contenu par l’objet atomic immédiatement avant l’exécution de l’opération.

Notes

La atomic_fetch_sub_explicit fonction effectue une opération en lecture-modification-écriture pour soustraire Value atomiquement la valeur stockée dans Atom, dans les memory_order contraintes spécifiées par Order.

Quand le type atomique est atomic_address, Value a le type ptrdiff_t et l’opération traite le pointeur stocké comme un char *.

Cette opération est également surchargée pour les types intégraux :

integral atomic_fetch_sub_explicit(
    volatile atomic-integral* Atom,
    integral Value,
    memory_order Order) noexcept;

integral atomic_fetch_sub_explicit(
    atomic-integral* Atom,
    integral Value,
    memory_order Order) noexcept;

atomic_fetch_xor

Effectue une opération exclusive or au niveau du bit sur une valeur et une valeur existante stockée dans un objet atomic.

template <class T>
inline T atomic_fetch_xor(volatile atomic<T>* Atom, T Value) noexcept;

template <class T>
inline T atomic_fetch_xor(volatile atomic<T>* Atom, T Value) noexcept;

Paramètres

Atom
Pointeur vers un objet atomic qui stocke une valeur de type T.

Value
Valeur de type T.

Valeur de retour

Valeur contenue par l’objet atomic immédiatement avant l’exécution de l’opération.

Notes

La atomic_fetch_xor fonction effectue une opération en lecture-modification-écriture pour remplacer la valeur stockée par Atom un bit au niveau exclusive or du Value bit et la valeur actuelle qui est stockée dans Atom, à l’aide du memory_order.memory_order_seq_cst.

atomic_fetch_xor_explicit

Effectue un bit dans le sens exclusive or du bit sur une valeur et une valeur existante stockée dans un atomic objet.

template <class T>
inline T atomic_fetch_xor_explicit(
    volatile atomic<T>* Atom,
    T Value,
    memory_order Order) noexcept;

template <class T>
inline T atomic_fetch_xor_explicit(
    volatile atomic<T>* Atom,
    T Value,
    memory_order Order) noexcept;

Paramètres

Atom
Pointeur vers un objet atomic qui stocke une valeur de type T.

Value
Valeur de type T.

Order
Un memory_order.

Valeur de retour

Valeur contenue par l’objet atomic immédiatement avant l’exécution de l’opération.

Notes

La atomic_fetch_xor_explicit fonction effectue une opération en lecture-modification-écriture pour remplacer la valeur stockée par Atom un bit au niveau exclusive or du Value bit et la valeur actuelle stockée dans Atom, dans les memory_order contraintes spécifiées par Order.

atomic_flag_clear

Définit l’indicateur bool dans un atomic_flag objet sur false, dans le memory_order.memory_order_seq_cst.

inline void atomic_flag_clear(volatile atomic_flag* Flag) noexcept;
inline void atomic_flag_clear(atomic_flag* Flag) noexcept;

Paramètres

Flag
Pointeur vers un objet atomic_flag .

atomic_flag_clear_explicit

Définit l’indicateur bool dans un atomic_flag objet falsesur , dans les contraintes spécifiées memory_order .

inline void atomic_flag_clear_explicit(volatile atomic_flag* Flag, memory_order Order) noexcept;
inline void atomic_flag_clear_explicit(atomic_flag* Flag, memory_order Order) noexcept;

Paramètres

Flag
Pointeur vers un objet atomic_flag .

Order
Un memory_order.

atomic_flag_test_and_set

Définit l’indicateur bool dans un atomic_flag objet truesur , dans les contraintes du memory_order.memory_order_seq_cst.

inline bool atomic_flag_test_and_set(volatile atomic_flag* Flag) noexcept;
inline bool atomic_flag_test_and_set(atomic_flag* Flag) noexcept;

Paramètres

Flag
Pointeur vers un objet atomic_flag .

Valeur de retour

Valeur initiale de Flag.

atomic_flag_test_and_set_explicit

Définit l’indicateur bool dans un atomic_flag objet truesur , dans les contraintes spécifiées memory_order .

inline bool atomic_flag_test_and_set_explicit(volatile atomic_flag* Flag, memory_order Order) noexcept;
inline bool atomic_flag_test_and_set_explicit(atomic_flag* Flag, memory_order Order) noexcept;

Paramètres

Flag
Pointeur vers un objet atomic_flag .

Order
Un memory_order.

Valeur de retour

Valeur initiale de Flag.

atomic_init

Définit la valeur stockée dans un objet atomic.

template <class Ty>
inline void atomic_init(volatile atomic<Ty>* Atom, Ty Value) noexcept;
template <class Ty>
inline void atomic_init(atomic<Ty>* Atom, Ty Value) noexcept;

Paramètres

Atom
Pointeur vers un objet atomic qui stocke une valeur de type Ty.

Value
Valeur de type Ty.

Notes

atomic_init n’est pas une opération atomique. Ce n’est pas thread-safe.

atomic_is_lock_free

Spécifie si les opérations atomiques sur un objet atomic sont sans verrou.

template <class T>
inline bool atomic_is_lock_free(const volatile atomic<T>* Atom) noexcept;
template <class T>
inline bool atomic_is_lock_free(const atomic<T>* Atom) noexcept;

Paramètres

Atom
Pointeur vers un objet atomic qui stocke une valeur de type T.

Valeur de retour

true si des opérations atomiques sur Atom sont sans verrou ; sinon, false.

Notes

Un type atomique est sans verrou si aucune opération atomique sur ce type utilise un verrou. Si cette fonction retourne true, le type est sûr à utiliser dans les gestionnaires de signal.

atomic_load

Récupère la valeur stockée dans un objet atomic.

template <class Ty>
inline Ty atomic_load(const volatile atomic<Ty>* Atom) noexcept;
template <class Ty>
inline Ty atomic_load(const atomic<Ty>* Atom) noexcept;

Paramètres

Atom
Pointeur vers un objet atomic qui contient une valeur de type Ty.

Valeur de retour

Valeur récupérée stockée dans Atom.

Notes

atomic_load utilise implicitement le memory_order.memory_order_seq_cst.

atomic_load_explicit

Récupère la valeur stockée dans un atomic objet, dans un objet spécifié memory_order.

template <class Ty>
inline Ty atomic_load_explicit(const volatile atomic<Ty>* Atom, memory_order Order) noexcept;
template <class Ty>
inline Ty atomic_load_explicit(const atomic<Ty>* Atom, memory_order Order) noexcept;

Paramètres

Atom
Pointeur vers un objet atomic qui contient une valeur de type Ty.

Order
Un memory_order. N'utilisez pas memory_order_release ou memory_order_acq_rel.

Valeur de retour

Valeur récupérée stockée dans Atom.

atomic_signal_fence

Agit comme une clôture , une primitive de synchronisation de mémoire qui applique l’ordre entre les opérations de chargement/magasin , entre d’autres clôtures dans un thread appelant qui ont des gestionnaires de signal qui sont exécutés dans le même thread.

inline void atomic_signal_fence(memory_order Order) noexcept;

Paramètres

Order
Contrainte d’ordre de mémoire qui détermine le type de délimitation.

Notes

L’argument Order détermine le type de délimitation.

Valeur Descriptif
memory_order_relaxed La délimitation est sans effet.
memory_order_consume La délimitation est une délimitation d’acquisition.
memory_order_acquire La délimitation est une délimitation d’acquisition.
memory_order_release La délimitation est une délimitation de libération.
memory_order_acq_rel La délimitation est une délimitation d’acquisition et de libération.
memory_order_seq_cst La délimitation est une délimitation d’acquisition et de libération, et est cohérente de manière séquentielle.

atomic_store

Stocke atomiquement une valeur dans un atomic objet.

template <class Ty>
inline Ty atomic_store_explicit(const volatile atomic<Ty>* Atom, Ty Value) noexcept;
template <class Ty>
inline Ty atomic_store_explicit(const atomic<Ty>* Atom, T Value) noexcept;

Paramètres

Atom
Pointeur vers un objet atomic qui contient une valeur de type Ty.

Value
Valeur de type Ty.

Notes

atomic_store stocke Value dans l’objet pointé par Atom, dans la memory_order.memory_order_seq_cst contrainte.

atomic_store_explicit

Stocke atomiquement une valeur dans un atomic objet.

template <class Ty>
inline Ty atomic_store_explicit(
    const volatile atomic<Ty>* Atom,
    Ty Value,
    memory_order Order) noexcept;

template <class Ty>
inline Ty atomic_store_explicit(
    const atomic<Ty>* Atom,
    T Value,
    memory_order Order) noexcept;

Paramètres

Atom
Pointeur vers un objet atomic qui contient une valeur de type Ty.

Value
Valeur de type Ty.

Order
Un memory_order. N’utilisez pas memory_order_consume, memory_order_acquire ou memory_order_acq_rel.

Notes

atomic_store stocke Value dans l’objet désigné par Atom, en respectant le memory_order spécifié par Order.

atomic_thread_fence

Agit comme une clôture , une primitive de synchronisation de mémoire qui applique l’ordre entre les opérations de chargement/magasin, sans opération atomique associée.

inline void atomic_thread_fence(memory_order Order) noexcept;

Paramètres

Order
Contrainte d’ordre de mémoire qui détermine le type de délimitation.

Notes

L’argument Order détermine le type de délimitation.

Valeur Descriptif
memory_order_relaxed La délimitation est sans effet.
memory_order_consume La délimitation est une délimitation d’acquisition.
memory_order_acquire La délimitation est une délimitation d’acquisition.
memory_order_release La délimitation est une délimitation de libération.
memory_order_acq_rel La délimitation est une délimitation d’acquisition et de libération.
memory_order_seq_cst La délimitation est une délimitation d’acquisition et de libération, et est cohérente de manière séquentielle.

kill_dependency

Supprime une dépendance.

template <class Ty>
Ty kill_dependency(Ty Arg) noexcept;

Paramètres

Arg
Valeur de type Ty.

Valeur de retour

La valeur de retour est Arg. L’évaluation de Arg ne comprend pas de dépendance à l’appel de fonction. En arrêtant une chaîne de dépendance possible, la fonction peut permettre au compilateur de générer du code plus efficace.

Voir aussi

<atomic>

  • Last updated on