# std::out_ptr_t<Smart,Pointer,Args...>::operator Pointer*, std::out_ptr_t<Smart,Pointer,Args...>::operator void**

> C++ Atlas: `cppatlas.com/w/cpp/memory/out_ptr_t/operator_ptr` | Source: https://en.cppreference.com/w/cpp/memory/out_ptr_t/operator_ptr | Domain: Memory management | Standards: C++23

Exposes the address of a Pointer or void* object to a foreign function which will generally re-initialize it.

## Official Specification Summary (cppreference)

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

Exposes the address of a `Pointer` or `void*` object to a foreign function which will generally re-initialize it.

1) Converts `*this` to the address of 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.

### Parameters

(none)

### Return value

1) The address of 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`.

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

> Note: This section is incomplete Reason: no example

---
Attribution: content from https://en.cppreference.com/w/cpp/memory/out_ptr_t/operator_ptr (cppreference.com), licensed under CC-BY-SA 3.0 and GFDL. Modified: converted to markdown, study notes added. Offline snapshot of 9 February 2025.