std::out_ptr_t
| Definido en el archivo de encabezado <memory>
|
||
template< class Smart, class Pointer, class... Args > class out_ptr_t; |
(desde C++23) | |
out_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**.
out_ptr_t captura argumentos adicionales en la construcción, proporciona un almacenamiento para el resultado en el que escribe la función externa antes mencionada y, finalmente, restablece el objeto Smart adaptado con el resultado y los argumentos capturados cuando se destruye.
out_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
TenArgs..., un miembro de tipoT, 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
Pointerdentro de él y para proporcionar un objetovoid*, dondePointero el objetovoid*generalmente está expuesto a una función externa para la reinicialización.
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) en el que una función externa escribe su resultado. |
| 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 y sizeof...(Args) == 0.
| ||
Especializaciones
A diferencia de la mayoría de las plantillas de clase de la biblioteca estándar, las especializaciones de out_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
(C++23) |
Construye un out_ptr_t. (función miembro pública) |
operator= [eliminada](C++23) |
out_ptr_t no es asignable. (función miembro pública) |
(C++23) |
Restablece el puntero inteligente adaptado. (función miembro pública) |
Convierte el out_ptr_t a la dirección del almacenamiento para la salida. (función miembro pública) |
Funciones no miembro
(C++23) |
Crea un objeto out_ptr_t con un puntero inteligente asociado y los argumentos de restablecimiento. (plantilla de función) |
Notas
out_ptr_t espera que las funciones externas no usen el valor al que apunta Pointer, y solo lo reinicialicen. No se utiliza el valor del puntero inteligente antes de la adaptación.
El uso típico de out_ptr_t es crear sus objetos temporales mediante std::out_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_setter(T**); y std::unique_ptr<T, D> up; respectivamente,
int foreign_setter(T**);
std::unique_ptr<T, D> up;
if (int ec = foreign_setter(std::out_ptr(up)) {
return ec;
}
es aproximadamente equivalente a
int foreign_setter(T**);
std::unique_ptr<T, D> up;
T* raw_p{};
int ec = foreign_setter(&raw_p);
up.reset(raw_p);
if (ec != 0) {
return ec;
}
No se recomienda crear un objeto out_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.
out_ptr_t prohíbe el uso que restablecería un std::shared_ptr sin especificar un eliminador, porque llamaría a std::shared_ptr::reset y reemplazaría un eliminador personalizado más tarde.
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
| Esta sección está incompleta Razón: sin ejemplo |
Véase también
(C++23) |
Interopera con establecedores de punteros externos, obtiene el valor del puntero inicial de un puntero inteligente y lo restablece en la destrucción. (plantilla de clase) |
(C++11) |
Puntero inteligente con semántica de posesión de objeto única. (plantilla de clase) |
(C++11) |
Puntero inteligente con semántica de posesión de objeto compartida. (plantilla de clase) |