std::experimental::atomic_shared_ptr<T>:: compare_exchange_strong, std::experimental::atomic_shared_ptr<T>:: compare_exchange_weak
|
bool
compare_exchange_weak
(
std::
shared_ptr
<
T
>
&
expected,
const
std::
shared_ptr
<
T
>
&
desired,
std:: memory_order success, std:: memory_order failure ) noexcept ; |
(1) | |
|
bool
compare_exchange_weak
(
std::
shared_ptr
<
T
>
&
expected,
std::
shared_ptr
<
T
>
&&
desired,
std:: memory_order success, std:: memory_order failure ) noexcept ; |
(2) | |
|
bool
compare_exchange_weak
(
std::
shared_ptr
<
T
>
&
expected,
const
std::
shared_ptr
<
T
>
&
desired,
std:: memory_order order = std:: memory_order_seq_cst ) noexcept ; |
(3) | |
|
bool
compare_exchange_weak
(
std::
shared_ptr
<
T
>
&
expected,
std::
shared_ptr
<
T
>
&&
desired,
std:: memory_order order = std:: memory_order_seq_cst ) noexcept ; |
(4) | |
|
bool
compare_exchange_strong
(
std::
shared_ptr
<
T
>
&
expected,
const
std::
shared_ptr
<
T
>
&
desired,
std:: memory_order success, std:: memory_order failure ) noexcept ; |
(5) | |
|
bool
compare_exchange_strong
(
std::
shared_ptr
<
T
>
&
expected,
std::
shared_ptr
<
T
>
&&
desired,
std:: memory_order success, std:: memory_order failure ) noexcept ; |
(6) | |
|
bool
compare_exchange_strong
(
std::
shared_ptr
<
T
>
&
expected,
const
std::
shared_ptr
<
T
>
&
desired,
std:: memory_order order = std:: memory_order_seq_cst ) noexcept ; |
(7) | |
|
bool
compare_exchange_strong
(
std::
shared_ptr
<
T
>
&
expected,
std::
shared_ptr
<
T
>
&&
desired,
std:: memory_order order = std:: memory_order_seq_cst ) noexcept ; |
(8) | |
Compare atomiquement le
shared_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
shared_ptr
, selon le cas.
Deux
shared_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 |
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_shared_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 retourne
true
,
expected
n'est pas accédé après l'étape de mise à jour atomique. Si elle retourne
false
,
expected
est mis à jour avec la valeur existante lue depuis l'objet
atomic_shared_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 elle-même dans
expected
n'est pas requise de 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 de manière sporadique, 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
spécialise les opérations atomiques pour
std::shared_ptr
(modèle de fonction) |