STD::__ATOMIC_BASE(3cxx)

✨ NAME ✨

std::__atomic_base< _ITp > — bestie, this is the base class for atomic integrals. That's it, that's the whole vibe. It lives in the libstdc++ manual, section 3cxx, and it's the lowkey iconic foundation everything atomic-integer-shaped gets built on top of. 💅

---

🦋 SYNOPSIS 🦋

🎀 Public Types 🎀

• using difference_type = value_type — literally just an alias pointing at value_type, she's not doing anything extra, she's just here. 🫶
• using value_type = _ITp — the actual type you templated in, wearing a little name tag. 🌸

💖 Public Member Functions 💖

okay so here's the whole roster, no skips, no shortcuts, every single overload accounted for. 🧚

• constexpr __atomic_base (__int_type __i) noexcept — the constructor. Takes an __int_type __i, is constexpr, is noexcept. She's ready.
• __atomic_base (const __atomic_base &)=delete — copy constructor? deleted. you cannot copy her, no cap. 🙈
• bool compare_exchange_strong (__int_type &__i1, __int_type __i2, memory_order __m1, memory_order __m2) noexcept — the strong one, with two explicit memory orders, __m1 and __m2. 💪
• bool compare_exchange_strong (__int_type &__i1, __int_type __i2, memory_order __m1, memory_order __m2) volatile noexcept — same thing but volatile, because she has a volatile twin and both of them showed up.
• bool compare_exchange_strong (__int_type &__i1, __int_type __i2, memory_order __m=memory_order_seq_cst) noexcept — the two-arg-memory-order version, defaulting to memory_order_seq_cst. default queen. 👑
• bool compare_exchange_strong (__int_type &__i1, __int_type __i2, memory_order __m=memory_order_seq_cst) volatile noexcept — and her volatile counterpart, obviously. ✨
• bool compare_exchange_weak (__int_type &__i1, __int_type __i2, memory_order __m1, memory_order __m2) noexcept — the weak one. same shape, two memory orders, __m1 and __m2.
• bool compare_exchange_weak (__int_type &__i1, __int_type __i2, memory_order __m1, memory_order __m2) volatile noexcept — weak + volatile, they come as a set.
• bool compare_exchange_weak (__int_type &__i1, __int_type __i2, memory_order __m=memory_order_seq_cst) noexcept — weak with the defaulted memory_order_seq_cst.
• bool compare_exchange_weak (__int_type &__i1, __int_type __i2, memory_order __m=memory_order_seq_cst) volatile noexcept — and the volatile one. four strongs, four weaks, we stay symmetrical. 🌈
• __int_type exchange (__int_type __i, memory_order __m=memory_order_seq_cst) noexcept — swap it out, takes __i, memory order defaults to memory_order_seq_cst.
• __int_type exchange (__int_type __i, memory_order __m=memory_order_seq_cst) volatile noexcept — volatile edition, same energy. 🦋
• __int_type fetch_add (__int_type __i, memory_order __m=memory_order_seq_cst) noexcept — fetch and add. 🍓
• __int_type fetch_add (__int_type __i, memory_order __m=memory_order_seq_cst) volatile noexcept — fetch and add, volatile flavour.
• __int_type fetch_and (__int_type __i, memory_order __m=memory_order_seq_cst) noexcept — fetch and bitwise-AND.
• __int_type fetch_and (__int_type __i, memory_order __m=memory_order_seq_cst) volatile noexcept — the volatile AND.
• __int_type fetch_or (__int_type __i, memory_order __m=memory_order_seq_cst) noexcept — fetch and bitwise-OR.
• __int_type fetch_or (__int_type __i, memory_order __m=memory_order_seq_cst) volatile noexcept — volatile OR.
• __int_type fetch_sub (__int_type __i, memory_order __m=memory_order_seq_cst) noexcept — fetch and subtract.
• __int_type fetch_sub (__int_type __i, memory_order __m=memory_order_seq_cst) volatile noexcept — subtract, but volatile.
• __int_type fetch_xor (__int_type __i, memory_order __m=memory_order_seq_cst) noexcept — fetch and bitwise-XOR. the spicy one. 🔥
• __int_type fetch_xor (__int_type __i, memory_order __m=memory_order_seq_cst) volatile noexcept — volatile XOR, equally spicy.
• bool is_lock_free () const noexcept — vibe check: is she lock free? asks so herself. 💀
• bool is_lock_free () const volatile noexcept — same question, const volatile this time.
• __int_type load (memory_order __m=memory_order_seq_cst) const noexcept — read the value out, const, memory order defaults to memory_order_seq_cst.
• __int_type load (memory_order __m=memory_order_seq_cst) const volatile noexcept — const volatile load, same default.
• void notify_all () const noexcept — wake everybody up. main character energy. 👑
• void notify_one () const noexcept — wake exactly one. mysterious. ✨
• operator __int_type () const noexcept — implicit conversion into __int_type, const.
• operator __int_type () const volatile noexcept — the const volatile conversion twin.
• __int_type operator&= (__int_type __i) noexcept — &= assignment operator, gives you back an __int_type.
• __int_type operator&= (__int_type __i) volatile noexcept — volatile &=.
• __int_type operator++ () noexcept — prefix increment, returns the __int_type.
• __int_type operator++ () volatile noexcept — prefix increment, volatile.
• __int_type operator++ (int) noexcept — postfix increment (that little int dummy argument), returns the __int_type.
• __int_type operator++ (int) volatile noexcept — postfix increment, volatile.
• __int_type operator+= (__int_type __i) noexcept — += that hands back an __int_type.
• __int_type operator+= (__int_type __i) volatile noexcept — volatile +=.
• __int_type operator-- () noexcept — prefix decrement.
• __int_type operator-- () volatile noexcept — prefix decrement, volatile.
• __int_type operator-- (int) noexcept — postfix decrement, with the int marker.
• __int_type operator-- (int) volatile noexcept — postfix decrement, volatile.
• __int_type operator-= (__int_type __i) noexcept — -=, returns __int_type.
• __int_type operator-= (__int_type __i) volatile noexcept — volatile -=.
• __int_type operator= (__int_type __i) noexcept — assign a raw __int_type in, get an __int_type out.
• __int_type operator= (__int_type __i) volatile noexcept — volatile assignment of the raw type.
• __atomic_base & operator= (const __atomic_base &) volatile=delete — assignment from another __atomic_base? deleted, and volatile too. nope. 🙈
• __atomic_base & operator= (const __atomic_base &)=delete — also deleted, the non-volatile one. you literally cannot do this, fr fr.
• __int_type operator^= (__int_type __i) noexcept — ^=, returns __int_type.
• __int_type operator^= (__int_type __i) volatile noexcept — volatile ^=.
• __int_type operator|= (__int_type __i) noexcept — |=, returns __int_type.
• __int_type operator|= (__int_type __i) volatile noexcept — volatile |=.
• void store (__int_type __i, memory_order __m=memory_order_seq_cst) noexcept — write a value in, memory order defaults to memory_order_seq_cst.
• void store (__int_type __i, memory_order __m=memory_order_seq_cst) volatile noexcept — volatile store, same default, same noexcept.
• void wait (__int_type __old, memory_order __m=memory_order_seq_cst) const noexcept — wait around for a change, const, memory order defaulting to memory_order_seq_cst. 💜

---

🌸 Detailed Description 🌸

okay so the actual declaration, verbatim, and yes there's a stray little " in there and we are keeping her exactly as she is, she's part of the lore: 🎀

template<typename _ITp>
    struct std::__atomic_base< _ITp >" Base class for atomic integrals.

Definition at line 324 of file atomic_base.h. 💖

---

🫶 Author 🫶

Generated automatically by Doxygen for libstdc++ from the source code. yes bestie, a robot wrote it, and honestly? she ate. ✨

---

and that's the whole page, no notes 💅 — this was libstdc++, dated Sat Mar 19 2022, from the std::__atomic_base< _ITp >(3cxx) manual. go forth and be atomic, periodt. 🌈⭐🎀