fonctions<atomic>
atomic_compare_exchange_strong
atomic_compare_exchange_strong_explicit
atomic_compare_exchange_weak
atomic_compare_exchange_weak_explicit
atomic_exchange
atomic_exchange_explicit
atomic_fetch_add
atomic_fetch_add_explicit
atomic_fetch_and
atomic_fetch_and_explicit
atomic_fetch_or
atomic_fetch_or_explicit
atomic_fetch_sub
atomic_fetch_sub_explicit
atomic_fetch_xor
atomic_fetch_xor_explicit
atomic_flag_clear
atomic_flag_clear_explicit
atomic_flag_test_and_set
atomic_flag_test_and_set_explicit
atomic_init
atomic_is_lock_free
atomic_load
atomic_load_explicit
atomic_signal_fence
atomic_store
atomic_store_explicit
atomic_thread_fence
kill_dependency
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 Atom Value, à 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 Atom Value, 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 , à Atoml’aide de Value 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
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
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 | Description |
|---|---|
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
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 | Description |
|---|---|
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.