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) | |
Vergleicht atomar den zugrundeliegenden
shared_ptr
in
*
this
mit
expected
, und wenn diese äquivalent sind, ersetzt den ersteren durch
desired
(führt eine Lese-Modifizier-Schreib-Operation aus). Andernfalls lädt den tatsächlich in
*
this
gespeicherten Wert in
expected
(führt eine Ladeoperation aus). Die Ersetzung wird wie durch den Kopier- oder Move-Zuweisungsoperator von
shared_ptr
durchgeführt, je nachdem was angemessen ist.
Zwei
shared_ptr
s sind äquivalent, wenn und nur wenn sie denselben Zeigerwert speichern und die Eigentümerschaft teilen.
Die Speichermodelle für die Lese-Modifizieren-Schreiben- und Ladeoperationen sind success und failure entsprechend. Für Überladungen (3,4,7,8) wird order sowohl für Lese-Modifizieren-Schreiben- als auch für Ladeoperationen verwendet, außer dass std::memory_order_acquire und std::memory_order_relaxed für die Ladeoperation verwendet werden, falls order == std:: memory_order_acq_rel oder order == std:: memory_order_release entsprechend.
Die schwachen Versionen (1-4) können sporadisch fehlschlagen.
Inhaltsverzeichnis |
Parameter
| expected | - | Referenz auf den Wert, der im atomaren Objekt erwartet wird |
| desired | - | der Wert, der im atomaren Objekt gespeichert werden soll, falls er wie erwartet ist |
| success | - | die Speichersynchronisationsreihenfolge für den Lese-Modifizier-Schreibe-Vorgang, falls der Vergleich erfolgreich ist. Alle Werte sind erlaubt |
| failure | - | die Speichersynchronisationsreihenfolge für den Ladevorgang, falls der Vergleich fehlschlägt. Darf nicht std::memory_order_release oder std::memory_order_acq_rel sein und darf keine stärkere Reihenfolge als success festlegen |
| order | - | die Speichersynchronisationsreihenfolge für beide Operationen |
Rückgabewert
true falls der zugrundeliegende atomare Wert geändert wurde, false andernfalls.
Anmerkungen
Alle Änderungen am
atomic_shared_ptr
-Objekt selbst und alle damit verbundenen
use_count
-Inkremente werden garantiert atomar ausgeführt. Zugehörige
use_count
-Dekremente finden nach der atomaren Operation statt, müssen jedoch nicht Teil davon sein. Alle zugehörigen Zerstörungs- oder Freigabeoperationen erfolgen nach der atomaren Operation und sind nicht Teil davon.
Wenn der Compare-Exchange-Vorgang
true
zurückgibt,
wird auf
expected
nach dem atomaren Aktualisierungsschritt nicht mehr zugegriffen. Wenn er
false
zurückgibt,
wird
expected
mit dem vorhandenen Wert aktualisiert, der aus dem
atomic_shared_ptr
-Objekt beim versuchten atomaren Update gelesen wurde. Die
use_count
-Aktualisierung entsprechend dem Schreibvorgang in
expected
ist Teil des atomaren Vorgangs, aber der Schreibvorgang in
expected
selbst muss nicht Teil des atomaren Vorgangs sein.
Für Überladungen (1,3,5,7) , desired wird nach dem atomaren Aktualisierungsschritt nicht zugegriffen.
Für Überladungen (2,4,6,8) wird desired nur dann verschoben, wenn der Compare-Exchange-Vorgang true zurückgibt; die Verschiebung erfolgt nach dem atomaren Aktualisierungsschritt.
Hinweise
Die schwachen Formen (1-4) der Funktionen dürfen sporadisch fehlschlagen, das heißt, sie können sich so verhalten, als ob * this und expected nicht äquivalent wären, selbst wenn sie es sind. Wenn ein Compare-and-Exchange in einer Schleife ausgeführt wird, liefert die schwache Version auf einigen Plattformen eine bessere Leistung.
Siehe auch
spezialisiert atomare Operationen für
std::shared_ptr
(Funktionstemplate) |