std::experi...r::operator=(3)

💅 NAME 💅

okay bestie, welcome to std::experi...r::operator=(3) from the C++ Standard Libary manual — yes, that’s the whole vibe. This page is all about:

• std::experimental::atomic_shared_ptr::operator= —
• std::experimental::atomic_shared_ptr::operator=

literally the assignment operators for atomic_shared_ptr, and they are lowkey iconic but also very specific. ✨

🌸 Synopsis 🌸

void operator=( shared_ptr<T> desired ) noexcept;    (1)
void operator=( const atomic_shared_ptr& ) = delete; (2)

1. Atomically assigns a value desired to the atomic variable. Equivalent to store(desired). 💖
2. Atomic variables are not CopyAssignable. periodt. 🚫

🎀 Parameters 🎀

• desired — value to assign. that’s it. that’s the parameter. 🫶

🦋 Notes 🦋

Unlike most assignment operators, the assignment operators for atomic_shared_ptr returns void. yes, void. not a reference, not a cute little chainable object — void. 💀

✨ Remarks ✨

All changes to the atomic_shared_ptr object itself, and all associated use_count increments, are guaranteed to be performed atomically. 🔥

Associated use_count decrements take place after the atomic operation, but are not required to be part of it.

Any associated destruction or deallocation operations take place after the atomic operation and are not part of it. no cap — the atomic part is the assignment; the cleanup aftermath is a separate era. 🌈

👑 See also 👑

• constructor — constructs an atomic_shared_ptr object (public member function)
• store — atomically replaces the value of the atomic object with a non-atomic argument (public member function)
• std::atomic_is_lock_free(std::shared_ptr)
• std::atomic_load(std::shared_ptr)
• std::atomic_load_explicit(std::shared_ptr)
• std::atomic_store(std::shared_ptr)
• std::atomic_store_explicit(std::shared_ptr)
• specializes atomic operations for std::shared_ptr (function template)
• std::atomic_exchange(std::shared_ptr)
• std::atomic_exchange_explicit(std::shared_ptr)
• std::atomic_compare_exchange_weak(std::shared_ptr)
• std::atomic_compare_exchange_strong(std::shared_ptr)
• std::atomic_compare_exchange_weak_explicit(std::shared_ptr)
• std::atomic_compare_exchange_strong_explicit(std::shared_ptr)
• (deprecated in C++20)
• (removed in C++26)

bestie note: assignment operator (2) is = delete, so copying an atomic_shared_ptr by assignment is not the move. the compiler said no and meant it. 🙈

and that’s the page, bestie 🎀 source/version: http://cppreference.com, dated 2024.06.10, under the title std::experi...r::operator=(3). slay. 💅✨