std:: out_ptr_t

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

out_ptr_t captura argumentos adicionales en la construcción, proporciona almacenamiento para el resultado al que escribe dicha función externa mencionada anteriormente, y finalmente restablece el objeto adaptado Smart con el resultado y los argumentos capturados cuando es destruido.

out_ptr_t se comporta como si contuviera los siguientes miembros de datos no estáticos:

• una referencia Smart& , que se vincula 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 utilizado para el reinicio durante la destrucción, y
• un subobjeto miembro adecuado para almacenar un Pointer dentro de él y proporcionar un objeto void * , donde el objeto Pointer o void * generalmente se expone a una función externa para reinicialización.

Los usuarios pueden controlar si cada argumento para el restablecimiento se captura por copia o por referencia, especificando un tipo de objeto o un tipo de referencia en Args... respectivamente.

Parámetros de plantilla

Especializaciones

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

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

Funciones miembro

Funciones no miembro

Notas

out_ptr_t espera que las funciones externas no utilicen el valor del puntero señalado Pointer , y solo lo reinicialicen. El valor del puntero inteligente antes de la adaptación no se utiliza.

El uso típico de out_ptr_t es crear sus objetos temporales mediante std::out_ptr , que restablece inmediatamente el puntero inteligente adaptado. Por ejemplo, dada una función establecedora y un puntero inteligente del tipo apropiado declarado 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 con una duración de almacenamiento diferente a la duración de almacenamiento automática, porque dicho código probablemente producirá referencias colgantes y resultará en comportamiento indefinido durante la destrucción.

out_ptr_t prohíbe el uso que reiniciaría un std::shared_ptr sin especificar un deleter, porque llamaría a std::shared_ptr::reset y reemplazaría un deleter personalizado posteriormente.

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

Ejemplo

Véase también