std::atomic...,--,--(int)(3)

💖 NAME 💖

okay bestie, you're in the C++ Standard Libary manual, on the std::atomic...,--,--(int)(3) page — aka the std::atomic_ref increment/decrement operator situation. 💅

The NAME line is exactly:

std::atomic_ref::operator++,++(int),--,--(int) -
std::atomic_ref::operator++,++(int),--,--(int)

🦋 Synopsis 🦋

These are members of atomic_ref<Integral> specializations and the atomic_ref<T*> partial specialization:

          member of atomic_ref<Integral> specializations
          and atomic_ref<T*> partial specialization
          value_type operator++() const noexcept;        (1) (since C++20)
          value_type operator++( int ) const noexcept;   (2) (since C++20)
          value_type operator--() const noexcept;        (3) (since C++20)
          value_type operator--( int ) const noexcept;   (4) (since C++20)

okay so these operators atomically increment or decrement the current value of the referenced object. They are read-modify-write operations, bestie. No cap. ✨

1. Performs atomic pre-increment. Equivalent to return fetch_add(1) + 1;.
2. Performs atomic post-increment. Equivalent to return fetch_add(1);.
3. Performs atomic pre-decrement. Equivalent to return fetch_sub(1) - 1;.
4. Performs atomic post-decrement. Equivalent to return fetch_sub(1);.

For signed Integral types, arithmetic is defined to use two’s complement representation. There are no undefined results. 🫶

For T* types, 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. ⚠️

🎁 Return value 🎁

• 1,3 — the value of the referenced object after the modification.
• 2,4 — the value of the referenced object before the modification.

🌸 Notes 🌸

Unlike most pre-increment and pre-decrement operators, the pre-increment and pre-decrement operators for atomic_ref do not return a reference to the modified object. They return a copy of the stored value instead. iconic behavior, honestly. 💅

👑 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-= — atomically adds to or subtracts from the referenced value (public member function)
• operator&=, operator|=, operator^= — atomically performs bitwise AND, OR, XOR with the referenced value (public member function)

and that's the page, bestie 🫶 — source/version: http://cppreference.com, date: 2024.06.10, page handle: std::atomic...,--,--(int)(3). periodt. 💅