std::atomic<T>:: operator+=,-=
|
membre uniquement des spécialisations
atomic<
Integral
>
et des spécialisations
atomic<
Floating
>
(depuis C++20)
|
||
|
T operator
+
=
(
T arg
)
noexcept
;
|
(1) | (depuis C++11) |
|
T operator
+
=
(
T arg
)
volatile
noexcept
;
|
(2) | (depuis C++11) |
|
T operator
-
=
(
T arg
)
noexcept
;
|
(3) | (depuis C++11) |
|
T operator
-
=
(
T arg
)
volatile
noexcept
;
|
(4) | (depuis C++11) |
|
membre uniquement de la spécialisation partielle
atomic<T*>
|
||
|
T
*
operator
+
=
(
std::
ptrdiff_t
arg
)
noexcept
;
|
(5) | (depuis C++11) |
|
T
*
operator
+
=
(
std::
ptrdiff_t
arg
)
volatile
noexcept
;
|
(6) | (depuis C++11) |
|
T
*
operator
-
=
(
std::
ptrdiff_t
arg
)
noexcept
;
|
(7) | (depuis C++11) |
|
T
*
operator
-
=
(
std::
ptrdiff_t
arg
)
volatile
noexcept
;
|
(8) | (depuis C++11) |
Remplace atomiquement la valeur actuelle par le résultat d'un calcul impliquant la valeur précédente et arg . L'opération est une opération de lecture-modification-écriture.
- operator + = effectue une addition atomique. Équivalent à return fetch_add ( arg ) + arg ; .
- operator - = effectue une soustraction atomique. Équivalent à return fetch_sub ( arg ) - arg ; .
|
Pour les types à virgule flottante, l' environnement de virgule flottante en vigueur peut être différent de l'environnement de virgule flottante du thread appelant. L'opération n'a pas besoin de se conformer aux traits correspondants de std::numeric_limits mais est encouragée à le faire. Si le résultat n'est pas une valeur représentable pour son type, le résultat est non spécifié mais l'opération n'a par ailleurs aucun comportement indéfini. |
(since C++20) |
T
n'est pas un type d'objet complet, le programme est mal formé.
|
Il est déprécié si std:: atomic < T > :: is_always_lock_free est false et qu'une surcharge volatile participe à la résolution de surcharge. |
(depuis C++20) |
Table des matières |
Paramètres
| arg | - | l'argument pour l'opération arithmétique |
Valeur de retour
La valeur résultante (c'est-à-dire le résultat de l'application de l'opérateur binaire correspondant à la valeur précédant immédiatement les effets de la fonction membre correspondante dans l' ordre de modification de * this ).
Notes
Contrairement à la plupart des opérateurs d'affectation composés, les opérateurs d'affectation composés pour les types atomiques ne renvoient pas de référence à leurs arguments de gauche. Ils renvoient plutôt une copie de la valeur stockée.
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é |
|---|---|---|---|
| P0558R1 | C++11 | arithmétique permise sur les pointeurs vers void (éventuellement qualifié cv) ou fonction | rendu non valide |
Voir aussi
|
ajoute atomiquement l'argument à la valeur stockée dans l'objet atomique et obtient la valeur détenue précédemment
(fonction membre publique) |
|
|
soustrait atomiquement l'argument de la valeur stockée dans l'objet atomique et obtient la valeur détenue précédemment
(fonction membre publique) |
|
|
incrémente ou décrémente la valeur atomique de un
(fonction membre publique) |
|
|
effectue un ET, OU, XOR bit à bit avec la valeur atomique
(fonction membre publique) |