std::inout_ptr_t<Smart,Pointer,Args...>::operator Pointer*, std::inout_ptr_t<Smart,Pointer,Args...>::operator void**
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.
*this to the address of stored
Pointer object.
*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
Pointer object.
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
Pointermember subobject may be used for both conversion functions, and (2) may directly returns its addressreinterpret_casttovoid**.
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
© cppreference.com
Licensed under the Creative Commons Attribution-ShareAlike Unported License v3.0.
https://en.cppreference.com/w/cpp/memory/inout_ptr_t/operator_ptr
