Namespaces
Variants

std::atomic_ref<T>:: compare_exchange_weak, std::atomic_ref<T>:: compare_exchange_strong

From cppreference.net
C++
Concurrency support library
Threads
(C++11)
(C++20)
(C++17) (C++17)
this_thread namespace
(C++11)
(C++11)
Cooperative cancellation
Mutual exclusion
Generic lock management
Condition variables
(C++11)
(C++11)
(C++11)
(C++11)
Semaphores
(C++20) (C++20)
Latches and Barriers
(C++20)
(C++20)
Futures
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Safe reclamation
Hazard pointers
(C++26)
(C++26)
(C++26)
Atomic types
(C++11)
(C++20)
(C++11)
Initialization of atomic types
(C++11) (deprecated in C++20)
(C++11) (deprecated in C++20)
(C++11)
Memory ordering
(C++11)
(C++11) (deprecated in C++26)
(C++11)
(C++11)
Free functions for atomic operations
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11) (C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++11) (C++11)
(C++26) (C++26)
(C++26) (C++26)
(C++11)
(C++20) (C++20)
(C++20)
(C++20)
Free functions for atomic flags
(C++11) (C++11)
(C++11) (C++11)
(C++20) (C++20)
(C++20) (C++20)
(C++20)
(C++20)
std::atomic_ref
Member functions
atomic_ref::compare_exchange_strong atomic_ref::compare_exchange_weak
(C++26)
Operations for arithmetic types
(except bool and pointer-to-object)
Operations for integral types
(except bool and pointer-to-object)
(C++26)
(C++26)
Operations for integral types
(except bool )
Constants
bool compare_exchange_weak

( value_type & expected, value_type desired,
std:: memory_order success,

std:: memory_order failure ) const noexcept ;
(1) (constexpr depuis C++26)
bool compare_exchange_weak

( value_type & expected, value_type desired,
std:: memory_order order =

std:: memory_order_seq_cst ) const noexcept ;
(2) (constexpr depuis C++26)
bool compare_exchange_strong

( value_type & expected, value_type desired,
std:: memory_order success,

std:: memory_order failure ) const noexcept ;
(3) (constexpr depuis C++26)
bool compare_exchange_strong

( value_type & expected, value_type desired,
std:: memory_order order =

std:: memory_order_seq_cst ) const noexcept ;
(4) (constexpr depuis C++26)

Compare atomiquement la représentation de la valeur de l'objet référencé avec celle de expected , et si elles sont égales bit à bit, remplace la première par desired (effectue une opération de lecture-modification-écriture). Sinon, charge la valeur actuelle stockée dans l'objet référencé dans expected (effectue une opération de chargement).

1,3) Les modèles de mémoire pour les opérations de lecture-modification-écriture et de chargement sont success et failure respectivement.
2,4) order est utilisé pour les opérations de lecture-modification-écriture et de chargement, sauf que std:: memory_order_acquire et std:: memory_order_relaxed sont utilisés pour l'opération de chargement si order est std:: memory_order_acq_rel ou std:: memory_order_release respectivement.

Ces surcharges participent à la résolution de surcharge seulement si std:: is_const_v < T > est false .

Si failure n'est pas std:: memory_order_relaxed , std:: memory_order_consume , std:: memory_order_acquire ou std:: memory_order_seq_cst , le comportement est indéfini.

Table des matières

Paramètres

expected - référence à la valeur attendue dans l'objet référencé par l'objet atomic_ref
desired - la valeur à stocker dans l'objet référencé si elle correspond à la valeur attendue
success - l'ordre de synchronisation mémoire pour l'opération de lecture-modification-écriture si la comparaison réussit
failure - l'ordre de synchronisation mémoire pour l'opération de chargement si la comparaison échoue
order - l'ordre de synchronisation mémoire pour les deux opérations

Valeur de retour

true si l'objet référencé a été modifié avec succès, false sinon.

Notes

La comparaison et la copie s'effectuent au niveau binaire (similaire à std::memcmp et std::memcpy ) ; aucun constructeur, opérateur d'affectation ou opérateur de comparaison n'est utilisé.

Les formes faibles (1,2) des fonctions peuvent échouer sporadiquement, c'est-à-dire agir comme si * this ! = expected même si elles sont égales. Lorsqu'un échange-comparaison est dans une boucle, la version faible offrira de meilleures performances sur certaines plateformes.

Lorsqu'un échange-comparaison faible nécessiterait une boucle et qu'un échange-comparaison fort ne le nécessiterait pas, ce dernier est préférable, sauf si la représentation objet du value_type peut inclure des bits piégés, ou offre plusieurs représentations objet pour la même valeur (par exemple, les NaN en virgule flottante). Dans ces cas, l'échange-comparaison faible fonctionne généralement car il converge rapidement vers une représentation objet stable.

Pour une union dont certains bits participent aux représentations de valeur de certains membres mais pas d'autres, la comparaison-et-échange peut toujours échouer car ces bits de remplissage ont des valeurs indéterminées lorsqu'ils ne participent pas à la représentation de valeur du membre actif.

Les bits de remplissage qui ne participent jamais à la représentation de la valeur d'un objet sont ignorés.

Rapports de défauts

Les rapports de défauts modifiant le comportement suivants ont été appliqués rétroactivement aux normes C++ précédemment publiées.

DR Appliqué à Comportement publié Comportement corrigé
LWG 3508
( P3323R1 ) 		C++20 compare_exchange_weak et compare_exchange_strong
n'avaient aucun sens pour const T 		contraint pour n'accepter que T non-const

Exemple

Cette section est incomplète
Raison : aucun exemple