std::out_pt...torPointer*,(3)

💖 std::out_ptr_t::operatorPointer* — C++ Standard Libary realness 💖

Okay bestie, this is the std::out_ptr_t::operatorPointer* page from the C++ Standard Libary, and the header is doing that truncated std::out_pt...torPointer*,(3) thing — mysterious, iconic, slightly chaotic. 🎀

🌸 NAME 🌸

std::out_ptr_t::operatorPointer*, — std::out_ptr_t::operatorPointer*, (yes, the same string twice, she's that kind of page 💀).

✨ Synopsis ✨

These are the two conversion-operator glow-ups, both noexcept, both since C++23:

operator Pointer*() const noexcept; (1) (since C++23)
operator void**() const noexcept;   (2) (since C++23)

So what's the vibe? It exposes the address of a Pointer or void* object to a foreign function which will generally re-initialize it. Little handoff moment, no cap. 🫶

1. Converts *this to the address of the stored Pointer object.
2. Converts *this to the address of a void* object. This conversion function participates in overload resolution only if Pointer is not same as void*, and the program is ill-formed if Pointer is not a pointer type. The initial value of the void* object is equal the value of the stored Pointer object converted to void*, and any modification to it affects the Pointer value used in the destructor. Accessing the void* object outside the lifetime of *this has undefined behavior.

Once one of these two conversion functions has been called on an out_ptr_t object, the other shall not be called on it, otherwise, the behavior is undefined. So like, pick one and commit, bestie. 💅

🎀 Parameters 🎀

• (none) — literally no parameters, she's self-sufficient. ✨

💜 Return value 💜

1. The address of the stored Pointer object.
2. The address of the void* object that satisfies aforementioned requirements.

🌈 Notes 🌈

If the object pointed by the return value has not been rewritten, it is equal to nullptr. Cute.

On common implementations, the object representation of every Pointer that is a pointer type is compatible with that of void*, and therefore these implementations typically store the void* object within the storage for the Pointer object, no additional storage needed:

• If the implementation enables type-based alias analysis (which relies on the strict aliasing rule), a properly aligned std::byte[sizeof(void*)] member subobject may be used, and both conversion functions return the address of objects implicitly created within the array.
• Otherwise, a Pointer member subobject may be used for both conversion functions, and (2) may directly returns its address reinterpret_cast to void**.

If Pointer is a pointer type whose object representation is incompatible with that of void*, an additional bool flag may be needed for recording whether (1) (or (2)) has been called.

🍓 Example 🍓

This section is incomplete.

Reason: no example.

Not me showing up to the example section and it's giving "under construction" 😭 no example yet, bestie.

🧚 Category 🧚

• Todo no example

---

Okay that's the whole page, periodt. Shoutout to the source http://cppreference.com, version/date 2024.06.10, and the footer title std::out_pt...torPointer*,(3) — mwah, slay. 💋👑