std::shared_ptr::get(3)

💅 std::shared_ptr::get(3) — C++ Standard Libary

Hey bestie, welcome to std::shared_ptr::get(3) from the C++ Standard Libary manual. Buckle up, because this one is short, iconic, and lowkey carrying a whole aliasing plot twist. 🎀

---

🌸 NAME 🌸

std::shared_ptr::get — std::shared_ptr::get

Yes bestie, the name is literally the name. No notes. 💅

---

✨ Synopsis ✨

T* get() const noexcept;             (until C++17)
element_type* get() const noexcept;  (since C++17)

Returns the stored pointer.

---

🎀 Parameters 🎀

• (none) — zero arguments, nada, the parentheses are empty and living their best life. 🫶

---

💖 Return value 💖

The stored pointer. Full stop. That's the whole return value, no hidden extras. ✨

---

🦋 Notes 🦋

A shared_ptr may share ownership of an object while storing a pointer to another object. Yes, bestie, it can do that — main character energy fr fr.

get() returns the stored pointer, not the managed pointer. Keep that distinction close to your heart. 💜

---

🔥 Example 🔥

// Run this code

#include <iostream>
#include <memory>
#include <string_view>

int main()
{
    auto output = [](std::string_view msg, int const* pInt)
    {
        std::cout << msg << *pInt << " in " << pInt << '\n';
    };

    int* pInt = new int(42);
    std::shared_ptr<int> pShared = std::make_shared<int>(42);

    output("Naked pointer: ", pInt);
//  output("Shared pointer: ", pShared); // compiler error
    output("Shared pointer: ", &*pShared); // OK, calls operator*, then
       takes addr
    output("Shared pointer with get(): ", pShared.get());

    delete pInt;

    std::cout << "\nThe shared_ptr's aliasing constructor demo.\n";
    struct Base1 { int i1{}; };
    struct Base2 { int i2{}; };
    struct Derived : Base1, Base2 { int i3{}; };

    std::shared_ptr<Derived> p(new Derived());
    std::shared_ptr<Base2> q(p, static_cast<Base2*>(p.get()));
    std::cout << "q shares ownership with p, but points to Base2
       subobject:\n"
              << "p.get(): " << p.get() << '\n'
              << "q.get(): " << q.get() << '\n'
              << "&(p->i1): " << &(p->i1) << '\n'
              << "&(p->i2): " << &(p->i2) << '\n'
              << "&(p->i3): " << &(p->i3) << '\n'
              << "&(q->i2): " << &(q->i2) << '\n';
}

🍓 Possible output 🍓

Naked pointer: 42 in 0xacac20
Shared pointer: 42 in 0xacac50
Shared pointer with get(): 42 in 0xacac50

The shared_ptr's aliasing constructor demo.
q shares ownership with p, but points to Base2 subobject:
p.get(): 0xacac20
q.get(): 0xacac24
&(p->i1): 0xacac20
&(p->i2): 0xacac24
&(p->i3): 0xacac28
&(q->i2): 0xacac24

---

👑 See also 👑

• operator* — dereferences the stored pointer
• operator-> — (public member function)

---

Okay bestie, that's the whole page! This little icon comes from http://cppreference.com, version dated 2024.06.10. Now go call get() responsibly and slay the aliasing game 💅✨🦋