std::out_ptr_t<Smart,Pointer,Args...>::operator Pointer*, std::out_ptr_t<Smart,Pointer,Args...>::operator void**
// 1)
operator Pointer*() const noexcept;
// 2)
operator void**() const noexcept;
Exposes the address of a Pointer or void*
object to a foreign function which will generally re-initialize it.
Converts *this
to the address of stored Pointer object.
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
The address of stored Pointer object.
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.