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

From cppreference.com
< cpp‎ | memory‎ | inout ptr t

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 release the ownership represented by its value and then 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 `inout_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 the value held by adapted `Smart` object before construction.

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

Retrieved from "https://en.cppreference.com/mwiki/index.php?title=cpp/memory/inout_ptr_t/operator_ptr&oldid=130200"