std::atomic...hange_strong(3)

💖 NAME 💖

okay bestie, welcome to the std::atomic...hange_strong(3) page from the C++ Standard Libary ✨ — yes, that manual name is literally spelled that way, no cap. This page is all about std::atomic_ref::compare_exchange_weak,std::atomic_ref::compare_exchange_strong 🫶, and it's giving atomic compare-and-swap realness.

---

✨ Synopsis ✨

Four overloads, all const and all noexcept — periodt 💅. Every one of them is (since C++20).

bool compare_exchange_weak( T& expected, T desired,
                            std::memory_order success,
                            std::memory_order failure ) const
noexcept;

(1) (since C++20)

bool compare_exchange_weak( T& expected, T desired,
                            std::memory_order order =
                                std::memory_order_seq_cst ) const
noexcept;

(2) (since C++20)

bool compare_exchange_strong( T& expected, T desired,
                              std::memory_order success,
                              std::memory_order failure ) const
noexcept;

(3) (since C++20)

bool compare_exchange_strong( T& expected, T desired,
                              std::memory_order order =
                                  std::memory_order_seq_cst ) const
noexcept;

(4) (since C++20)

So here's the vibe 🦋: it atomically compares the value representation of the referenced object with that of expected, and if those are bitwise-equal, it replaces the former with desired — that's a read-modify-write operation, bestie 🔥. Otherwise, it loads the actual value stored in the referenced object into expected — that's a load operation, slay.

The memory models for the read-modify-write and load operations are success and failure respectively. In the (2) and (4) versions, order is used for both read-modify-write and load operations, except that std::memory_order_acquire and std::memory_order_relaxed are used for the load operation if order == std::memory_order_acq_rel, or order == std::memory_order_release respectively. literally the details matter, iykyk 💜.

---

🌸 Parameters 🌸

• expected — reference to the value expected to be found in the object referenced by the atomic_ref object 👑.
• desired — the value to store in the referenced object if it is as expected 🎀.
• success — the memory synchronization ordering for the read-modify-write operation if the comparison succeeds. All values are permitted ✨.
• failure — the memory synchronization ordering for the load operation if the comparison fails. Cannot be std::memory_order_release or std::memory_order_acq_rel — noted, bestie 🫶.
• order — the memory synchronization ordering for both operations 💅.

---

🌈 Return value 🌈

true if the referenced object was successfully changed, false otherwise. simple as that, no cap 💖.

---

🦋 Notes 🦋

The comparison and copying are bitwise — similar to std::memcmp and std::memcpy — and no constructor, assignment operator, or comparison operator are used. it's giving low-level, and we respect it 😌.

The weak forms (1,2) of the functions are allowed to fail spuriously, that is, act as if *this != expected even if they are equal. When a compare-and-exchange is in a loop, the weak version will yield better performance on some platforms — highkey useful info, bestie ⭐.

When a weak compare-and-exchange would require a loop and a strong one would not, the strong one is preferable unless the object representation of T may include trap bits, or offers multiple object representations for the same value (e.g. floating-point NaN). In those cases, weak compare-and-exchange typically works because it quickly converges on some stable object representation. obsessed with a function that knows how to converge 💀✨.

For a union with bits that participate in the value representations of some members but not the others, compare-and-exchange might always fail because such padding bits have indeterminate values when they do not participate in the value representation of the active member. padding bit drama, honestly 🙈.

Padding bits that never participate in an object's value representation are ignored. iconic behavior, honestly 🎀.

---

🍓 Example 🍓

This section is incomplete Reason: no example

not me noticing there's literally no example 😭 — the manual page said it, not me, bestie.

---

🧚 Category 🧚

• Todo no example

---

okay that's the whole page, bestie — mwah 💋. source: http://cppreference.com, version/date: 2024.06.10, and the manual page is std::atomic...hange_strong(3) — periodt 💅✨.