std::experimental::atomic_weak_ptr<T>::compare_exchange_strong, std::experimental::atomic_weak_ptr<T>::compare_exchange_weak
| bool compare_exchange_weak( std::weak_ptr<T>& expected, const std::weak_ptr<T>& desired, std::memory_order success, std::memory_order failure ) noexcept; |
(1) | |
| bool compare_exchange_weak( std::weak_ptr<T>& expected, std::weak_ptr<T>&& desired, std::memory_order success, std::memory_order failure ) noexcept; |
(2) | |
| bool compare_exchange_weak( std::weak_ptr<T>& expected, const std::weak_ptr<T>& desired, std::memory_order order = std::memory_order_seq_cst ) noexcept; |
(3) | |
| bool compare_exchange_weak( std::weak_ptr<T>& expected, std::weak_ptr<T>&& desired, std::memory_order order = std::memory_order_seq_cst ) noexcept; |
(4) | |
| bool compare_exchange_strong( std::weak_ptr<T>& expected, const std::weak_ptr<T>& desired, std::memory_order success, std::memory_order failure ) noexcept; |
(5) | |
| bool compare_exchange_strong( std::weak_ptr<T>& expected, std::weak_ptr<T>&& desired, std::memory_order success, std::memory_order failure ) noexcept; |
(6) | |
| bool compare_exchange_strong( std::weak_ptr<T>& expected, const std::weak_ptr<T>& desired, std::memory_order order = std::memory_order_seq_cst ) noexcept; |
(7) | |
| bool compare_exchange_strong( std::weak_ptr<T>& expected, std::weak_ptr<T>&& desired, std::memory_order order = std::memory_order_seq_cst ) noexcept; |
(8) | |
Atomically vergleicht den zugrunde liegenden weak_ptr in *this mit expected, und falls sie äquivalent sind, ersetzt er den ersteren durch desired (führt eine Lese-Modifizierungs-Schreib-Operation durch). Andernfalls wird der tatsächliche Wert, der in *this gespeichert ist, in expected geladen (führt eine Lese-Operation durch). Die Ersetzung erfolgt so, als ob durch den Kopier- oder Zuweisungsoperator von weak_ptr, wie zutreffend.
Zwei weak_ptrs sind genau dann äquivalent, wenn sie denselben Zeigerwert speichern und sich den Besitz teilen.
Die Speichermodelle für die Lese-Modifizierungs-Schreib- und Lese-Operationen sind success und failure bzw. Für Überladungen (3,4,7,8) wird order sowohl für Lese-Modifizierungs-Schreib- als auch für Lese-Operationen verwendet, außer dass std::memory_order_acquire und std::memory_order_relaxed für die Lese-Operation verwendet werden, wenn order == std::memory_order_acq_rel bzw. order == std::memory_order_release.
Die schwachen Versionen (1-4) können fehlschlagen (spuriously).
Inhalt |
[edit] Parameter
| expected | - | Referenz auf den Wert, von dem erwartet wird, dass er im atomaren Objekt gefunden wird |
| desired | - | der Wert, der in das atomare Objekt geschrieben werden soll, wenn er wie erwartet ist |
| erfolgreich | - | die Speicher-Synchronisationsreihenfolge für die Lese-Modifizierungs-Schreib-Operation, wenn der Vergleich erfolgreich ist. Alle Werte sind zulässig |
| failure | - | die Speicher-Synchronisationsreihenfolge für die Lese-Operation, wenn der Vergleich fehlschlägt. Darf nicht std::memory_order_release oder std::memory_order_acq_rel sein und darf keine stärkere Ordnung als success angeben |
| Reihenfolge | - | die Speicher-Synchronisationsreihenfolge für beide Operationen |
[edit] Rückgabewert
true, wenn der zugrunde liegende atomare Wert geändert wurde, false andernfalls.
[edit] Hinweise
Alle Änderungen am atomic_weak_ptr-Objekt selbst und alle zugehörigen Inkremente von use_count werden garantiert atomar durchgeführt. Zugehörige Dekremente von use_count erfolgen nach der atomaren Operation, müssen aber nicht Teil davon sein. Jegliche zugehörige Zerstörungs- oder Freigabeoperationen erfolgen nach der atomaren Operation und sind nicht Teil davon.
Wenn die Vergleichs-Austausch-Operation true zurückgibt, wird expected nach dem atomaren Aktualisierungsschritt nicht mehr zugegriffen. Wenn sie false zurückgibt, wird expected mit dem vorhandenen Wert aktualisiert, der beim versuchten atomaren Update aus dem atomic_weak_ptr-Objekt gelesen wurde. Die use_count-Aktualisierung, die dem Schreiben nach expected entspricht, ist Teil der atomaren Operation, aber das Schreiben nach expected selbst muss nicht Teil der atomaren Operation sein.
Für Überladungen (1,3,5,7) wird desired nach dem atomaren Aktualisierungsschritt nicht mehr zugegriffen.
Für Überladungen (2,4,6,8) wird desired nur dann verschoben (moved from), wenn die Vergleichs-Austausch-Operation true zurückgibt; das Verschieben erfolgt nach dem atomaren Aktualisierungsschritt.
[edit] Anmerkungen
Die schwachen Formen (1-4) der Funktionen dürfen aus beliebigen Gründen fehlschlagen (spuriously), d.h. so wirken, als wären *this und expected nicht äquivalent, auch wenn sie es sind. Wenn ein Vergleichs-Austausch in einer Schleife stattfindet, bietet die schwache Version auf einigen Plattformen eine bessere Leistung.
[edit] Siehe auch
spezialisiert atomare Operationen für std::shared_ptr(Funktionsschablone) |
