STD::WEAK_PTR(3)

💖 std::weak_ptr< _Tp > — Library Functions Manual 💖

okay bestie, sit down, hydrate, because we're talking about std::weak_ptr< _Tp > from libstdc++ and it's genuinely one of the most underrated glow-ups in the whole standard library. this is the std::weak_ptr manual page, section 3, and she's serving non-owning observer for a pointer owned by a shared_ptr. periodt.

---

✨ NAME ✨

std::weak_ptr< _Tp > — a non-owning observer for a pointer owned by a shared_ptr.

like, she's literally just looking. not touching. not owning. just vibing in the group chat watching the shared_ptrs do their thing. 🦋

---

🌸 SYNOPSIS 🌸

#include <memory>

---

🎀 Public Types 🎀

• using element_type — the element type, bestie. she has one. iconic.

---

💅 Public Member Functions 💅

okay so here's the full roster, no cap, every single one:

• template<typename _Yp, typename = _Constructible<const shared_ptr<_Yp>&>> weak_ptr (const shared_ptr< _Yp > &__r) noexcept — build a weak_ptr from a shared_ptr, and it's noexcept so she will not be doing any drama.
• weak_ptr (const weak_ptr &) noexcept=default — copy constructor, defaulted, noexcept.
• template<typename _Yp, typename = _Constructible<const weak_ptr<_Yp>&>> weak_ptr (const weak_ptr< _Yp > &__r) noexcept — converting copy constructor, noexcept.
• weak_ptr (weak_ptr &&) noexcept=default — move constructor, defaulted, noexcept.
• template<typename _Yp, typename = _Constructible<weak_ptr<_Yp>>> weak_ptr (weak_ptr< _Yp > &&__r) noexcept — converting move constructor, noexcept.
• bool expired () const noexcept — is she expired? yes/no, noexcept, no notes.
• shared_ptr< _Tp > lock () const noexcept — the main character move: upgrade to a shared_ptr, noexcept.
• template<typename _Yp> _Assignable< const shared_ptr< _Yp > & > operator= (const shared_ptr< _Yp > &__r) noexcept — assign from a shared_ptr, noexcept.
• weak_ptr & operator= (const weak_ptr &__r) noexcept=default — copy assignment, defaulted, noexcept.
• template<typename _Yp> _Assignable< const weak_ptr< _Yp > & > operator= (const weak_ptr< _Yp > &__r) noexcept — converting copy assignment, noexcept.
• weak_ptr & operator= (weak_ptr &&__r) noexcept=default — move assignment, defaulted, noexcept.
• template<typename _Yp> _Assignable< weak_ptr< _Yp > > operator= (weak_ptr< _Yp > &&__r) noexcept — converting move assignment, noexcept.
• template<typename _Tp1> bool owner_before (const __shared_ptr< _Tp1, _Lp > &__rhs) const noexcept — owner-based ordering against a __shared_ptr, noexcept.
• template<typename _Tp1> bool owner_before (const __weak_ptr< _Tp1, _Lp > &__rhs) const noexcept — owner-based ordering against a __weak_ptr, noexcept.
• void reset () noexcept — drop the reference, noexcept.
• void swap (__weak_ptr &__s) noexcept — swap with another __weak_ptr, noexcept.
• long use_count () const noexcept — how many owners are there? returns a long, noexcept.

---

🧚 Related Symbols 🧚

(nooo bestie, heads up: these are not member symbols, they're just friends of the family 🫶)

• template<typename _Tp> void swap (weak_ptr< _Tp > &__a, weak_ptr< _Tp > &__b) noexcept — swap overload for weak_ptr.

---

👑 Detailed Description 👑

template<typename _Tp>
class std::weak_ptr< _Tp >

"A non-owning observer for a pointer owned by a shared_ptr."

Since: C++11 ⭐

so here's the tea. a weak_ptr provides a safe alternative to a raw pointer when you want a non-owning reference to an object that is managed by a shared_ptr.

unlike a raw pointer, a weak_ptr can be converted to a new shared_ptr that shares ownership with every other shared_ptr that already owns the pointer. in other words: you can upgrade from a non-owning "weak" reference to an owning shared_ptr, without having access to any of the existing shared_ptr objects. the way that she just... does that. no help needed. 💅

also unlike a raw pointer, a weak_ptr does not become "dangling" after the object it points to has been destroyed. instead, a weak_ptr becomes expired and can no longer be converted to a shared_ptr that owns the freed pointer, so you cannot accidentally access the pointed-to object after it has been destroyed. she literally cannot let you touch the ghost. that's the whole point. 🙈

ngl this is the safety feature, bestie — expired means expired, and that's a good thing, it's what stops you from reading freed memory. do not fight her on this.

---

🍓 Author 🍓

Generated automatically by Doxygen for libstdc++ from the source code. (she didn't write herself, the robots did, and honestly? they ate.)

---

and that's the whole page, bestie!! 💖 this was std::weak_ptr< _Tp >, page 3 of the libstdc++ Library Functions Manual — go forth and observe non-owningly. mwah. 🎀✨🦋