std::inout_ptr_t

 

C++

Apoyo de compiladores

Implementaciones independientes y albergadas

Lenguaje

Biblioteca estándar

Encabezados de la biblioteca estándar

Requisitos denominados

Macros de prueba de característica (C++20)

Biblioteca de apoyo del lenguaje

Biblioteca de conceptos (C++20)

Biblioteca de diagnósticos

Biblioteca de gestión de memoria

Biblioteca de metaprogramación (C++11)

Biblioteca de servicios generales

Biblioteca de contenedores

Biblioteca de iteradores

Biblioteca de rangos (C++20)

Biblioteca de algoritmos

Biblioteca de cadenas

Biblioteca de procesamiento de texto

Biblioteca numérica

Biblioteca de fecha y hora

Biblioteca de entrada/salida

Biblioteca del sistema de archivos (C++17)

Biblioteca de apoyo de concurrencia (C++11)

Biblioteca de apoyo de ejecución (C++26)

Especificaciones técnicas

Índice de símbolos

Bibliotecas externas

 

Biblioteca de servicios

Apoyo del lenguaje Apoyo de tipos (tipos básicos, RTTI) Biblioteca de macros de prueba de característica (C++20) Servicios del programa Apoyo de corrutinas (C++20) Funciones variádicas is_constant_evaluated (C++20) is_within_lifetime (C++26) initializer_list (C++11) source_location (C++20) Comparación de tres vías three_way_comparablethree_way_comparable_with (C++20)(C++20) strong_ordering (C++20) weak_ordering (C++20) partial_ordering (C++20) common_comparison_category (C++20) compare_three_way_result (C++20) compare_three_way (C++20) strong_order (C++20) weak_order (C++20) partial_order (C++20) compare_strong_order_fallback (C++20) compare_weak_order_fallback (C++20) compare_partial_order_fallback (C++20)   is_eqis_ltis_lteq (C++20)(C++20)(C++20)   is_neqis_gtis_gteq (C++20)(C++20)(C++20)

Servicios generales Objetos función Manipulación de bits (C++20) bitset hash (C++11) Operadores relacionales (en desuso en C++20) rel_ops::operator!=rel_ops::operator>    rel_ops::operator<=rel_ops::operator>= Funciones de comparación de enteros cmp_equalcmp_lesscmp_less_than (C++20)(C++20)(C++20)   cmp_not_equalcmp_greatercmp_greater_than (C++20)(C++20)(C++20) in_range (C++20) Intercambio y operaciones de tipos swap ranges::swap (C++20) exchange (C++14) declval (C++11) to_underlying (C++23) forward (C++11) forward_like (C++23) move (C++11) move_if_noexcept (C++11) as_const (C++17) Tipos vocabulario comunes pair tuple (C++11) optional (C++17) any (C++17) variant (C++17) tuple_size (C++11) tuple_element (C++11) apply (C++17) make_from_tuple (C++17) expected (C++23)

 

Gestión de memoria dinámica

Punteros inteligentes unique_ptr (C++11) shared_ptr (C++11) weak_ptr (C++11) auto_ptr (hasta C++17) owner_less (C++11) 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) Asignadores de memoria allocator allocator_traits (C++11) allocation_result (C++23) allocate_at_least (C++23) allocator_arg_t (C++11) allocator_arg (C++11) uses_allocator (C++11) uses_allocator_construction_args (C++20) make_obj_using_allocator (C++20) uninitialized_construct_using_allocator (C++20) scoped_allocator_adaptor (C++11) pmr::polymorphic_allocator (C++17) Recursos de memoria pmr::memory_resource (C++17) pmr::get_default_resource (C++17) pmr::set_default_resource (C++17) pmr::new_delete_resource (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) pmr::pool_options (C++17) Almacenamiento no inicializado raw_storage_iterator (hasta C++20) get_temporary_buffer (hasta C++20) return_temporary_buffer (hasta C++20)

Algoritmos de memoria no inicializada uninitialized_copy uninitialized_fill uninitialized_move (C++17) uninitialized_default_construct (C++17) uninitialized_value_construct (C++17) destroy (C++17) destroy_at (C++17) uninitialized_copy_n (C++11) uninitialized_fill_n uninitialized_move_n (C++17) uninitialized_default_construct_n (C++17) uninitialized_value_construct_n (C++17) destroy_n (C++17) construct_at (C++20) Algoritmos restringidos de memoria no inicializada ranges::uninitialized_copy (C++20) ranges::uninitialized_fill (C++20) ranges::uninitialized_move (C++20) ranges::uninitialized_default_construct (C++20) ranges::uninitialized_value_construct (C++20) ranges::destroy (C++20) ranges::destroy_at (C++20) ranges::uninitialized_copy_n (C++20) ranges::uninitialized_fill_n (C++20) ranges::uninitialized_move_n (C++20) ranges::uninitialized_default_construct_n (C++20) ranges::uninitialized_value_construct_n (C++20) ranges::destroy_n (C++20) ranges::construct_at (C++20) Apoyo para recolección de basura declare_reachable (C++11)(hasta C++23) undeclare_reachable (C++11)(hasta C++23) declare_no_pointers (C++11)(hasta C++23) undeclare_no_pointers (C++11)(hasta C++23) pointer_safety (C++11)(hasta C++23) get_pointer_safety (C++11)(hasta C++23) Misceláneos pointer_traits (C++11) to_address (C++20) addressof (C++11) align (C++11) assume_aligned (C++20) Biblioteca de C malloc aligned_alloc (C++17) calloc realloc free Gestión de memoria de bajo nivel operator new operator new[] operator delete operator delete[] get_new_handler set_new_handler bad_alloc bad_array_new_length nothrow_t align_val_t destroying_delete_t new_handler nothrow

 

std::inout_ptr_t

Funciones miembro

inout_ptr_t::inout_ptr_t (C++23)

inout_ptr_t::~inout_ptr_t (C++23)

inout_ptr_t::operator Pointer*inout_ptr_t::operator void** (C++23)(C++23)

Funciones no miembro

inout_ptr (C++23)

 

<tbody> </tbody>

Definido en el archivo de encabezado <memory>
template< class Smart, class Pointer, class... Args > class inout_ptr_t;		(desde C++23)

See More

inout_ptr_t se usa para adaptar tipos como punteros inteligentes para funciones externas que generan sus resultados a través de un Pointer* (generalmente T** para algún tipo de objeto T) o parámetro void**.

inout_ptr_t captura argumentos adicionales durante la construcción, proporciona un almacenamiento para el resultado al que accede dicha función externa mencionada anteriormente, libera la propiedad del objeto Smart adaptado y, finalmente, restablece el objeto Smart adaptado con el resultado y los argumentos capturados cuando se destruye.

inout_ptr_t se comporta como si tuviera los siguientes datos miembro no estáticos:

• una referencia Smart&, que está vinculada al objeto adaptado durante la construcción,
• para cada T en Args..., un miembro de tipo T, que es un argumento capturado durante la construcción y usado para restablecer durante la destrucción, y
• un subobjeto miembro que es adecuado para almacenar un Pointer dentro de él y para proporcionar un objeto void*, donde Pointer o el objeto void* generalmente está expuesto a una función externa para restablecer la propiedad.

Si Smart no es un tipo puntero, se llama a release() a lo sumo una vez sobre el objeto adaptado. Las implementaciones pueden llamar a release() dentro del constructor, o antes de restablecer dentro del destructor si el valor de Pointer no es nulo.

Los usuarios pueden controlar si cada argumento a restablecer se captura por copia o por referencia, especificando un tipo objeto o un tipo referencia en Args... respectivamente.

Parámetros de plantilla

Smart	-	El tipo de objeto (típicamente un puntero inteligente) a adaptar.
Pointer	-	El tipo del objeto (normalmente un puntero sin formato) al que accede una función externa para restablecer la propiedad.
Args...	-	El tipo de los argumentos capturados utilizados para restablecer el objeto adaptado.
Requisitos de tipo
- Pointer debe satisfacer los requisitos de NullablePointer.
- El programa está mal formado si Smart es una especialización de std::shared_ptr.

Especializaciones

A diferencia de la mayoría de las plantillas de clase de la biblioteca estándar, las especializaciones de inout_ptr_t definidas por el programa que dependen de al menos un tipo definido por el programa no necesitan cumplir con los requerimientos de la plantilla principal.

Esta licencia permite que una especialización definida por el programa exponga el puntero sin formato almacenado en un puntero inteligente no estándar a las funciones externas.

Funciones miembro

(constructor) (C++23)	Construye un inout_ptr_t. (función miembro pública)
operator= [eliminada](C++23)	inout_ptr_t no es asignable. (función miembro pública)
(destructor) (C++23)	Restablece el puntero inteligente adaptado después de liberar su propiedad. (función miembro pública)
operator Pointer*operator void** (C++23)	Convierte el inout_ptr_t a la dirección del almacenamiento para la salida. (función miembro pública)

Funciones no miembro

inout_ptr (C++23)

Crea un objeto inout_ptr_t con un puntero inteligente asociado y los argumentos de restablecimiento. (plantilla de función)

Notas

inout_ptr_t espera que las funciones externas liberen la propiedad representada por el valor al que apunta Pointer y luego lo reinicialicen. Como tal operación requiere propiedad única, el uso con std::shared_ptr está prohibido.

El uso típico de inout_ptr_t es crear sus objetos temporales mediante std::inout_ptr, que restablece el puntero inteligente adaptado inmediatamente. Por ejemplo, dada una función establecedora (setter) y un puntero inteligente del tipo apropiado declarada con int foreign_resetter(T**); y std::unique_ptr<T, D> up; respectivamente,

if (int ec = foreign_resetter(std::inout_ptr(up)) {
    return ec;
}

es aproximadamente equivalente a

T *raw_p = up.get();
up.release();
int ec = foreign_resetter(&raw_p);
up.reset(raw_p);
if (ec != 0) {
    return ec;
}

No se recomienda crear un objeto inout_ptr_t de una duración de almacenamiento que no sea la duración de almacenamiento automática, porque es probable que dicho código produzca referencias pendientes y resulte en un comportamiento no definido durante la destrucción.

Los argumentos capturados normalmente se empaquetan en std::tuple<Args...>. Las implementaciones pueden usar diferentes mecanismos para proporcionar el objeto Pointer o void* que necesitan retener.

Macro de Prueba de característica
__cpp_lib_out_ptr

Ejemplo

Véase también

out_ptr_t (C++23)	Interopera con establecedores de punteros externos y restablece un puntero inteligente en la destrucción. (plantilla de clase)
unique_ptr (C++11)	Puntero inteligente con semántica de posesión de objeto única. (plantilla de clase)
shared_ptr (C++11)	Puntero inteligente con semántica de posesión de objeto compartida. (plantilla de clase)