Namensräume
Varianten
Aktionen

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

Von cppreference.com
< cpp‎ | atomic‎ | atomic ref
 
C++
 
Bibliothek für nebenläufige Programmierung
Threads
(C++11)
(C++20)
(C++17)(C++17)
this_thread Namespace
(C++11)
(C++11)
(C++11)
(C++11)
Kooperatives Beenden
Gegenseitiger Ausschluss
(C++11)
(C++11)
(C++17)
Allgemeines Sperrungsmanagement
(C++11)
(C++11)
(C++17)
(C++11)
(C++14)
(C++11)
(C++11)
(C++11)
(C++11)(C++11)(C++11)(C++11)(C++11)(C++11)
Bedingungsvariablen
(C++11)
(C++11)
(C++11)
(C++11)
Semaphoren
(C++20)(C++20)
Latches und Barriers
(C++20)
(C++20)
Futures
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
(C++11)
Sichere Wiederherstellung
(C++26)
(C++26)
(C++26)
Hazard Pointer
(C++26)
(C++26)
(C++26)
Atomare Typen
(C++11)
(C++20)
(C++11)
Initialisierung von atomaren Typen
(C++11)(veraltet in C++20)
(C++11)(veraltet in C++20)
(C++11)
Speicherordnung
(C++11)
(C++11)(deprecated in C++26)
(C++11)
(C++11)
Freie Funktionen für atomare Operationen
(C++11)(C++11)
(C++11)(C++11)
(C++11)(C++11)
(C++11)(C++11)(C++11)(C++11)
(C++11)(C++11)
(C++11)(C++11)
(C++11)(C++11)
(C++11)(C++11)
(C++11)(C++11)
(C++26)(C++26)
(C++26)(C++26)
(C++11)
(C++20)(C++20)
(C++20)
(C++20)
Freie Funktionen für atomare Flags
(C++11)(C++11)
(C++11)(C++11)
(C++20)(C++20)
(C++20)(C++20)
(C++20)
(C++20)
 
std::atomic_ref
Memberfunktionen
atomic_ref::compare_exchange_strongatomic_ref::compare_exchange_weak
(C++26)
Operationen für arithmetische Typen
(außer bool und Zeiger auf Objekte)
Operationen für ganzzahlige Typen
(außer bool und Zeiger auf Objekte)
(C++26)
(C++26)
Operationen für ganzzahlige Typen
(außer bool)
Konstanten
 
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 ersteres durch desired (führt eine Lese-Modifikations-Schreib-Operation durch). Andernfalls lädt sie den tatsächlich im referenzierten Objekt gespeicherten Wert in expected (führt eine Lese-Operation durch).

1,3) Die Speichermodelle für die Lese-Modifikations-Schreib-Operation und die Lese-Operation sind success bzw. failure.
2,4) order wird sowohl für die Lese-Modifikations-Schreib-Operation als auch für die Lese-Operation verwendet, mit der Ausnahme, dass std::memory_order_acquire und std::memory_order_relaxed für die Lese-Operation verwendet werden, wenn order std::memory_order_acq_rel oder std::memory_order_release ist.

Diese Überladungen nehmen nur 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.

Inhalt

[bearbeiten] Parameter

expected - Referenz auf den Wert, der im von atomic_ref referenzierten Objekt erwartet wird.
desired - Der Wert, der im referenzierten Objekt gespeichert werden soll, wenn er wie erwartet ist.
erfolgreich - die Speicher-Synchronisationsreihenfolge für die Lese-Änderungs-Schreib-Operation, wenn der Vergleich erfolgreich ist
failure - die Speicher-Synchronisationsreihenfolge für die Ladeoperation, wenn der Vergleich fehlschlägt
Reihenfolge - die Speicher-Synchronisationsreihenfolge für beide Operationen

[bearbeiten] Rückgabewert

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

[bearbeiten] Hinweise

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

Die schwachen Formen (1,2) der Funktionen dürfen fehlschlagen, d.h. sie können sich so verhalten, als wäre *this != expected, auch wenn sie gleich sind. Wenn ein Vergleich-und-Austausch in einer Schleife verwendet wird, erzielt die schwache Version auf einigen Plattformen eine bessere Leistung.

Wenn ein schwacher Vergleich-und-Austausch eine Schleife erfordert und ein starker nicht, ist der starke vorzuziehen, es sei denn, die Wertdarstellung von value_type kann Trap-Bits enthalten oder bietet mehrere Wertdarstellungen für denselben Wert (z. B. Gleitkomma-NaN). In diesen Fällen funktioniert ein schwacher Vergleich-und-Austausch typischerweise, da er schnell zu einer stabilen Wertdarstellung konvergiert.

Für eine Union mit Bits, die an den Wertrepräsentationen einiger Member, aber nicht der anderen teilnehmen, kann ein Compare-and-Exchange immer fehlschlagen, da solche Auffüllbits undefinierte Werte haben, wenn sie nicht an der Wertrepräsentation des aktiven Members teilnehmen.

Auffüllbits, die niemals an der Wertrepräsentation eines Objekts teilnehmen, werden ignoriert.

[bearbeiten] Meldungen zu Fehlern

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

DR angewendet auf Verhalten wie veröffentlicht Korrigiertes Verhalten
LWG 3508
(P3323R1)		 C++20 compare_exchange_weak und compare_exchange_strong
waren bedeutungslos für const T		 constrained to accept only non-const T

[bearbeiten] Beispiel

Dieser Abschnitt ist unvollständig
Grund: kein Beispiel
Abgerufen von "https://cppreference.de/mwiki/index.php?title=cpp/atomic/atomic_ref/compare_exchange&oldid=179568"