std::experimental::atomic_weak_ptr<T>:: compare_exchange_strong, std::experimental::atomic_weak_ptr<T>:: compare_exchange_weak

bool compare_exchange_weak ( std:: weak_ptr < T > & expected, const std:: weak_ptr < T > & desired, std:: memory_order success, std:: memory_order failure ) noexcept ;	(1)
bool compare_exchange_weak ( std:: weak_ptr < T > & expected, std:: weak_ptr < T > && desired, std:: memory_order success, std:: memory_order failure ) noexcept ;	(2)
bool compare_exchange_weak ( std:: weak_ptr < T > & expected, const std:: weak_ptr < T > & desired, std:: memory_order order = std:: memory_order_seq_cst ) noexcept ;	(3)
bool compare_exchange_weak ( std:: weak_ptr < T > & expected, std:: weak_ptr < T > && desired, std:: memory_order order = std:: memory_order_seq_cst ) noexcept ;	(4)
bool compare_exchange_strong ( std:: weak_ptr < T > & expected, const std:: weak_ptr < T > & desired, std:: memory_order success, std:: memory_order failure ) noexcept ;	(5)
bool compare_exchange_strong ( std:: weak_ptr < T > & expected, std:: weak_ptr < T > && desired, std:: memory_order success, std:: memory_order failure ) noexcept ;	(6)
bool compare_exchange_strong ( std:: weak_ptr < T > & expected, const std:: weak_ptr < T > & desired, std:: memory_order order = std:: memory_order_seq_cst ) noexcept ;	(7)
bool compare_exchange_strong ( std:: weak_ptr < T > & expected, std:: weak_ptr < T > && desired, std:: memory_order order = std:: memory_order_seq_cst ) noexcept ;	(8)

Compare atomiquement le weak_ptr sous-jacent dans * this avec expected , et s'ils sont équivalents, remplace le premier par desired (effectue une opération de lecture-modification-écriture). Sinon, charge la valeur réelle stockée dans * this dans expected (effectue une opération de chargement). Le remplacement est effectué comme par l'opérateur d'affectation par copie ou par déplacement de weak_ptr , selon le cas.

Deux weak_ptr sont équivalents si et seulement s'ils stockent la même valeur de pointeur et partagent la propriété.

Les modèles de mémoire pour les opérations de lecture-modification-écriture et de chargement sont success et failure respectivement. Pour les surcharges (3,4,7,8) , order est utilisé à la fois 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 == std:: memory_order_acq_rel , ou order == std:: memory_order_release respectivement.

Les versions faibles (1-4) peuvent échouer sporadiquement.

Table des matières 1 Paramètres 2 Valeur de retour 3 Remarques 4 Notes 5 Voir aussi

Paramètres

expected	-	référence à la valeur attendue dans l'objet atomique
desired	-	la valeur à stocker dans l'objet atomique s'il correspond à la valeur attendue
success	-	l'ordre de synchronisation mémoire pour l'opération de lecture-modification-écriture si la comparaison réussit. Toutes les valeurs sont autorisées
failure	-	l'ordre de synchronisation mémoire pour l'opération de chargement si la comparaison échoue. Ne peut pas être std::memory_order_release ou std::memory_order_acq_rel et ne peut pas spécifier un ordonnancement plus strict que success
order	-	l'ordre de synchronisation mémoire pour les deux opérations

Valeur de retour

true si la valeur atomique sous-jacente a été modifiée, false sinon.

Remarques

Toutes les modifications apportées à l'objet atomic_weak_ptr lui-même, et tous les incréments associés du use_count , sont garantis d'être effectués atomiquement. Les décréments associés du use_count ont lieu après l'opération atomique, mais ne font pas nécessairement partie de celle-ci. Toute opération de destruction ou de désallocation associée a lieu après l'opération atomique et n'en fait pas partie.

Si l'opération compare-exchange renvoie true , expected n'est pas accédé après l'étape de mise à jour atomique. Si elle renvoie false , expected est mis à jour avec la valeur existante lue depuis l'objet atomic_weak_ptr lors de la tentative de mise à jour atomique. La mise à jour du use_count correspondant à l'écriture dans expected fait partie de l'opération atomique, mais l'écriture dans expected elle-même n'est pas requise pour faire partie de l'opération atomique.

Pour les surcharges (1,3,5,7) , desired n'est pas accédé après l'étape de mise à jour atomique.

Pour les surcharges (2,4,6,8) , desired est déplacé uniquement si l'opération de comparaison-échange retourne true ; le déplacement se produit après l'étape de mise à jour atomique.

Notes

Les formes faibles (1-4) des fonctions peuvent échouer sporadiquement, c'est-à-dire agir comme si * this et expected n'étaient pas équivalents même lorsqu'ils le sont. Lorsqu'un échange-comparaison est dans une boucle, la version faible offrira de meilleures performances sur certaines plateformes.

Voir aussi

std::atomic_is_lock_free (std::shared_ptr) std::atomic_load (std::shared_ptr) std::atomic_load_explicit (std::shared_ptr) std::atomic_store (std::shared_ptr) std::atomic_store_explicit (std::shared_ptr) std::atomic_exchange (std::shared_ptr) std::atomic_exchange_explicit (std::shared_ptr) std::atomic_compare_exchange_weak (std::shared_ptr) std::atomic_compare_exchange_strong (std::shared_ptr) std::atomic_compare_exchange_weak_explicit (std::shared_ptr) std::atomic_compare_exchange_strong_explicit (std::shared_ptr) (obsolète en C++20) (supprimé en C++26)

spécialise les opérations atomiques pour std::shared_ptr (modèle de fonction)