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

 

C++

Compiler support

Freestanding and hosted

Language

Standard library

Standard library headers

Named requirements

Feature test macros (C++20)

Language support library

Concepts library (C++20)

Diagnostics library

Memory management library

Metaprogramming library (C++11)

General utilities library

Containers library

Iterators library

Ranges library (C++20)

Algorithms library

Strings library

Text processing library

Numerics library

Date and time library

Input/output library

Filesystem library (C++17)

Concurrency support library (C++11)

Execution control library (C++26)

Technical specifications

Symbols index

External libraries

 

Memory management library

Allocators allocator allocator_traits (C++11) allocation_result (C++23) scoped_allocator_adaptor (C++11) allocator_arg (C++11) uses_allocator (C++11) uses_allocator_construction_args (C++20) make_obj_using_allocator (C++20) pmr::polymorphic_allocator (C++17) uninitialized_construct_using_allocator (C++20) Memory resources pmr::memory_resource (C++17) pmr::get_default_resource (C++17)     pmr::set_default_resource (C++17) pmr::new_delete_resource (C++17) pmr::pool_options (C++17) pmr::null_memory_resource (C++17) pmr::synchronized_pool_resource (C++17) pmr::unsynchronized_pool_resource (C++17)     pmr::monotonic_buffer_resource (C++17) Explicit lifetime management start_lifetime_as (C++23) start_lifetime_as_array (C++23) Types for composite class design indirect (C++26) polymorphic (C++26) Miscellaneous pointer_traits (C++11) to_address (C++20) addressof (C++11) align (C++11) assume_aligned (C++20) is_sufficiently_aligned (C++26) C Library malloc      free calloc realloc aligned_alloc (C++17) free_sized (C++26) free_aligned_sized (C++26) memalignment (C++26) Uninitialized storage (until C++20*) raw_storage_iterator get_temporary_buffer return_temporary_buffer Garbage collector support (until C++23) declare_reachable (C++11) declare_no_pointers (C++11) pointer_safety (C++11) undeclare_reachable (C++11) undeclare_no_pointers (C++11) get_pointer_safety (C++11)

Specialized <memory> algorithms Low level memory management operator newoperator new[] operator deleteoperator delete[] nothrow nothrow_t new_handler set_new_handler get_new_handler (C++11) bad_alloc bad_array_new_length (C++11) align_val_t (C++17) destroying_delete_t (C++20) launder (C++17) Smart pointers unique_ptr (C++11) shared_ptr (C++11) weak_ptr (C++11) auto_ptr (until C++17*) owner_less (C++11) owner_less<void> (C++17) owner_hash (C++26) owner_equal (C++26) enable_shared_from_this (C++11) bad_weak_ptr (C++11) default_delete (C++11) out_ptr_t (C++23) inout_ptr_t (C++23)

 

std::inout_ptr_t

Member functions

inout_ptr_t::inout_ptr_t

inout_ptr_t::~inout_ptr_t

inout_ptr_t::operator Pointer*inout_ptr_t::operator void**

Non-member functions

inout_ptr

 

operator Pointer*() const noexcept;	(1)	(since C++23) (constexpr since C++26)
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.

If operator void**() has been called on *this, the behavior is undefined.

2) Converts *this to the address of a void* object.

This overload participates in overload resolution only if std::is_same_v<Pointer, void*> is false.

If std::is_pointer_v<Pointer> is false, the program is ill-formed.

Returns a pointer ptr satisfying all following conditions:

• The initial value of *ptr is equivalent to the value of the stored Pointer object converted to void*.
• Any modification of *ptr that is not followed by a subsequent modification of *this affects the Pointer value used in the destructor.

If operator Pointer*() has been called on *this, the behavior is undefined.

If *ptr is accessed outside the lifetime of *this, the behavior is undefined.

Return value

1) A pointer to the stored Pointer object.

2) A pointer to 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 operator void** 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 operator Pointer* (or operator void**) has been called.