std::atomic...erator+=,-=(3)

💖 std::atomic_ref::operator+=,-= 💖

okay so this is the C++ Standard Libary manual page for std::atomic...erator+=,-=(3), and we’re about to make atomic compound assignment make sense, bestie. no cap. ✨

🎀 NAME 🎀

std::atomic_ref::operator+=,-= — std::atomic_ref::operator+=,-=

✨ Synopsis ✨

these are the four overloads, fr fr:

member only of atomic_ref<Integral> and atomic_ref<Floating> specializations
T operator+=( T arg ) const noexcept;
(1) (since C++20)
T operator-=( T arg ) const noexcept;
(2) (since C++20)
member only of atomic_ref<T*> partial specialization
T* operator+=( std::ptrdiff_t arg ) const noexcept;
(3) (since C++20)
T* operator-=( std::ptrdiff_t arg ) const noexcept;
(4) (since C++20)

so like: overloads (1) and (2) are member only of atomic_ref<Integral> and atomic_ref<Floating> specializations, and overloads (3) and (4) are member only of the atomic_ref<T*> partial specialization. periodt. 💅

🌸 Description 🌸

Atomically replaces the current value of the referenced object with the result of computation involving the previous value and arg. These operations are read-modify-write operations. it’s giving very “do the math, but atomically” energy. 🔥

• operator+= performs atomic addition. Equivalent to return fetch_add(arg) + arg;.
• operator-= performs atomic subtraction. Equivalent to return fetch_sub(arg) - arg;.
• 1,2) — For signed integral types, arithmetic is defined to use two’s complement representation. There are no undefined results. For floating-point types, the floating-point environment in effect may be different from the calling thread's floating-point environment. The operation need not be conform to the corresponding std::numeric_limits traits but is encouraged to do so. If the result is not a representable value for its type, the result is unspecified but the operation otherwise has no undefined behavior.
• 3,4) — The result may be an undefined address, but the operations otherwise have no undefined behavior. The program is ill-formed if T is not an object type.

💖 Parameters 💖

• arg — the argument for the arithmetic operation

🦋 Return value 🦋

The resulting value (that is, the result of applying the corresponding binary operator to the value immediately preceding the effects of the corresponding member function).

🍓 Notes 🍓

Unlike most compound assignment operators, the compound assignment operators for atomic_ref do not return a reference to their left-hand arguments. They return a copy of the stored value instead. lowkey important, bestie. 🫶

🌈 Example 🌈

This section is incomplete.

Reason: no example.

not me showing up with no example 😭 but the facts are still facts.

👑 See also 👑

• fetch_add — atomically adds the argument to the value stored in the referenced object and obtains the value held previously (public member function)
• fetch_sub — atomically subtracts the argument from the value stored in the referenced object and obtains the value held previously (public member function)
• operator++, operator++(int) — atomically increments or decrements the referenced object by one (public member function)
• operator--, operator--(int) — atomically increments or decrements the referenced object by one (public member function)
• operator&=, operator|=, operator^= — atomically performs bitwise AND, OR, XOR with the referenced value (public member function)

🧚 Category 🧚

• Todo no example

---

xoxo, your Unix bestie 💅 — source: http://cppreference.com, version/date: 2024.06.10, page: std::atomic...erator+=,-=(3).