Namespaces
Variants

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

From cppreference.net
Concurrency support library
Threads
(C++11)
(C++20)
this_thread namespace
(C++11)
(C++11)
Cooperative cancellation
Mutual exclusion
Generic lock management
Condition variables
(C++11)
Semaphores
Latches and Barriers
(C++20)
(C++20)
Futures
(C++11)
(C++11)
(C++11)
Safe reclamation
Hazard pointers
Atomic types
(C++11)
(C++20)
Initialization of atomic types
(C++11) (deprecated in C++20)
(C++11) (deprecated in C++20)
Memory ordering
(C++11) (deprecated in C++26)
Free functions for atomic operations
Free functions for atomic flags
bool compare_exchange_weak

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

std:: memory_order failure ) const noexcept ;
(1) (constexpr seit 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 seit C++26)
bool compare_exchange_strong

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

std:: memory_order failure ) const noexcept ;
(3) (constexpr seit 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 seit C++26)

Vergleicht atomar die Wertdarstellung des referenzierten Objekts mit der von expected , und falls diese bitweise gleich sind, ersetzt die erstere durch desired (führt einen Lese-Modifizieren-Schreibe-Vorgang aus). Andernfalls lädt den tatsächlichen Wert, der im referenzierten Objekt gespeichert ist, in expected (führt einen Ladevorgang aus).

1,3) Die Speichermodelle für die Lese-Modifizieren-Schreiben- und Ladeoperationen sind success und failure entsprechend.
2,4) order wird 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, wenn order gleich std:: memory_order_acq_rel oder std:: memory_order_release ist.

Diese Überladungen nehmen nur dann an der Überladungsauflösung teil, wenn std:: is_const_v < T > false ist.

Wenn failure nicht std:: memory_order_relaxed , std:: memory_order_consume , std:: memory_order_acquire oder std:: memory_order_seq_cst ist, ist das Verhalten undefiniert.

Inhaltsverzeichnis

Parameter

expected - Referenz auf den Wert, der voraussichtlich im Objekt gefunden wird, auf das das atomic_ref -Objekt verweist
desired - der Wert, der im referenzierten Objekt gespeichert werden soll, falls es dem erwarteten Wert entspricht
success - die Speichersynchronisationsreihenfolge für den Lese-Modifizier-Schreib-Vorgang, falls der Vergleich erfolgreich ist
failure - die Speichersynchronisationsreihenfolge für den Ladevorgang, falls der Vergleich fehlschlägt
order - die Speichersynchronisationsreihenfolge für beide Vorgänge

Rückgabewert

true wenn das referenzierte Objekt erfolgreich geändert wurde, false andernfalls.

Hinweise

Der Vergleich und das Kopieren erfolgen bitweise (ähnlich wie std::memcmp und std::memcpy ); es werden keine Konstruktoren, Zuweisungsoperatoren oder Vergleichsoperatoren verwendet.

Die schwachen Formen (1,2) der Funktionen können sporadisch fehlschlagen, das heißt, sie können sich so verhalten, als ob * this ! = expected selbst wenn sie gleich sind. Wenn ein Compare-and-Exchange in einer Schleife stattfindet, liefert die schwache Version auf einigen Plattformen eine bessere Leistung.

Wenn ein schwacher Compare-and-Exchange eine Schleife erfordern würde und ein starker nicht, ist der starke vorzuziehen, es sei denn, die Objektdarstellung von value_type kann Trap-Bits enthalten oder bietet mehrere Objektdarstellungen für denselben Wert (z.B. Gleitkomma-NaN). In diesen Fällen funktioniert schwacher Compare-and-Exchange typischerweise, da er schnell auf eine stabile Objektdarstellung konvergiert.

Für eine Union mit Bits, die an den Wertdarstellungen einiger Mitglieder teilnehmen, aber nicht an anderen, könnte Compare-and-Exchange immer fehlschlagen, weil solche Padding-Bits unbestimmte Werte haben, wenn sie nicht an der Wertdarstellung des aktiven Mitglieds teilnehmen.

Padding-Bits, die niemals an der Wertdarstellung eines Objekts teilnehmen, werden ignoriert.

Fehlerberichte

Die folgenden verhaltensändernden Fehlerberichte wurden rückwirkend auf zuvor veröffentlichte C++-Standards angewendet.

DR Angewendet auf Veröffentlichtes Verhalten Korrigiertes Verhalten
LWG 3508
( P3323R1 )
C++20 compare_exchange_weak und compare_exchange_strong
waren bedeutungslos für const T
eingeschränkt, um nur non-const T zu akzeptieren

Beispiel