STD::ATOMIC(3)

💖 std::atomic< _Tp > — the generic atomic type, primary class template 💖

okay bestie so this is std::atomic< _Tp >(3), straight outta the Library Functions Manual, and it's genuinely one of the most iconic glow-ups in the whole C++ standard library. no cap. if you've ever had two threads fighting over the same variable like it's the last matcha in the fridge, this is the class template that ends the drama. 🫶

---

✨ NAME ✨

std::atomic< _Tp > — Generic atomic type, primary class template. that's the whole vibe. it's the primary one, the blueprint, the main character 👑

---

🌈 SYNOPSIS 🌈

#include <atomic>

🎀 Public Types

• using value_type — yeah it's just chillin' there, one type, doing its thing.

🦋 Public Member Functions

okay this list is LONG and I am NOT skipping a single one, because every overload here is a baddie and they all earned their spot 💅

• constexpr atomic (_Tp __i) noexcept — build one of these, feed it your starting value __i, no exceptions, we don't do that here.
• atomic (const atomic &)=delete — nope. copying is deleted. atoms don't get duplicated, that's the whole point, periodt. 💀
• bool compare_exchange_strong (_Tp &__e, _Tp __i, memory_order __m=memory_order_seq_cst) noexcept — the strong compare-and-swap. if the current value matches __e, swap in __i and say true; otherwise write the actual value back into __e and say false. default ordering memory_order_seq_cst.
• bool compare_exchange_strong (_Tp &__e, _Tp __i, memory_order __m=memory_order_seq_cst) volatile noexcept — same energy, but volatile.
• bool compare_exchange_strong (_Tp &__e, _Tp __i, memory_order __s, memory_order __f) noexcept — strong version where you get to pick two orderings: __s for success, __f for failure. so flexible ✨
• bool compare_exchange_strong (_Tp &__e, _Tp __i, memory_order __s, memory_order __f) volatile noexcept — the volatile twin of the above.
• bool compare_exchange_weak (_Tp &__e, _Tp __i, memory_order __m=memory_order_seq_cst) noexcept — the weak one. same deal, same default ordering, but it's allowed to fail even when the values match (spurious failure is real, that's just how it is on some hardware).
• bool compare_exchange_weak (_Tp &__e, _Tp __i, memory_order __m=memory_order_seq_cst) volatile noexcept — weak, volatile, iconic.
• bool compare_exchange_weak (_Tp &__e, _Tp __i, memory_order __s, memory_order __f) noexcept — weak + your choice of success ordering __s and failure ordering __f.
• bool compare_exchange_weak (_Tp &__e, _Tp __i, memory_order __s, memory_order __f) volatile noexcept — and the volatile version of that one too. we contain multitudes.
• _Tp exchange (_Tp __i, memory_order __m=memory_order_seq_cst) noexcept — drop in __i and hand back the old value. give and receive, that's the exchange. 💞
• _Tp exchange (_Tp __i, memory_order __m=memory_order_seq_cst) volatile noexcept — exchange, but volatile.
• bool is_lock_free () const noexcept — asks the question we all ask: is this thing actually lock-free, or is it secretly locking under the hood? const, no exceptions.
• bool is_lock_free () const volatile noexcept — same question, const volatile flavour.
• _Tp load (memory_order __m=memory_order_seq_cst) const noexcept — read the value out. default ordering memory_order_seq_cst, const, noexcept. 📖
• _Tp load (memory_order __m=memory_order_seq_cst) const volatile noexcept — load, but const volatile.
• operator _Tp () const noexcept — surprise! it implicitly converts to _Tp, so you can just use it like a regular value. the versatility 😭
• operator _Tp () const volatile noexcept — the const volatile conversion operator, obviously.
• _Tp operator= (_Tp __i) noexcept — assign a plain _Tp into it, get the value back. noexcept, as always.
• _Tp operator= (_Tp __i) volatile noexcept — the volatile assignment.
• atomic & operator= (const atomic &) volatile =delete — copy-assignment? deleted. volatile flavour. NO copying, bestie, I said what I said.
• atomic & operator= (const atomic &)=delete — and the non-volatile one is deleted too. both doors locked 🔒
• void store (_Tp __i, memory_order __m=memory_order_seq_cst) noexcept — write __i in. default ordering memory_order_seq_cst, returns nothing, throws nothing. clean.
• void store (_Tp __i, memory_order __m=memory_order_seq_cst) volatile noexcept — store, volatile edition.

---

👑 Detailed Description 👑

template<typename _Tp>
    struct std::atomic< _Tp >

"Generic atomic type, primary class template."

that's the official blurb and honestly? it ate. this is the primary class template, the one all the specializations look up to.

🌸 Template Parameters

• _Tp — Type to be made atomic, must be trivially copyable. lowkey the most important sentence on this page. if your type isn't trivially copyable, this template is NOT the one for you, and it will let you know. 🙈

---

💜 Author

Generated automatically by Doxygen for libstdc++ from the source code. no human author to thank here, just the machine doing its little automated thing. 🤖✨

---

and that's the page, bestie!! 🎀 this one came to you from libstdc++, filed under std::atomic< _Tp >(3) — so next time you're in the terminal and you see that section-3 header, you'll know exactly who you're dealing with. go forth and atomically. 💅🦋⭐