Namespaces
Variants

std:: out_ptr

From cppreference.net
C++
Memory management library
( exposition only* )
Allocators
Uninitialized memory algorithms
Constrained uninitialized memory algorithms
Memory resources
Uninitialized storage (until C++20)
( until C++20* )
( until C++20* )
( until C++20* )

Garbage collector support (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
(C++11) (until C++23)
std::out_ptr_t
Definido en el encabezado <memory>
template < class Pointer = void , class Smart, class ... Args >
auto out_ptr ( Smart & s, Args && ... args ) ;
(desde C++23)

Devuelve un std::out_ptr_t con argumentos de plantilla deducidos que captura argumentos para restablecer por referencia.

El programa está mal formado si la construcción del valor de retorno (ver abajo) está mal formada.

Contenidos

Parámetros

s - el objeto (normalmente un puntero inteligente) a adaptar
args... - los argumentos para resetear a capturar

Valor de retorno

std:: out_ptr_t < Smart, P, Args && > ( s, std:: forward < Args > ( args ) ... ) , donde P es

  • Pointer , si Pointer no es un tipo void . De lo contrario,
  • Smart :: pointer , si es válido y denota un tipo. De lo contrario,
  • Smart :: element_type * , si Smart :: element_type es válido y denota un tipo. De lo contrario,
  • std:: pointer_traits < Smart > :: element_type * .

Notas

Los usuarios pueden especificar el argumento de plantilla para el parámetro de plantilla Pointer , para interoperar con funciones externas que toman un Pointer * .

Como todos los argumentos para el reset son capturados por referencia, el objeto out_ptr_t devuelto debe ser un objeto temporal destruido al final de la expresión completa que contiene la llamada a la función externa, para evitar referencias colgantes.

Macro de prueba de características Valor Estándar Característica
__cpp_lib_out_ptr 202106L (C++23) std::out_ptr , std::inout_ptr
202311L (C++26) Implementación independiente de std::out_ptr y std::inout_ptr

Ejemplo

Utilice std::out_ptr para adaptar un puntero inteligente para sqlite3_open , que espera un sqlite3** como parámetro de salida.

Ejecutar este código 
#include <memory>
#include <sqlite3.h>
int main()
{
    auto close_db = [](sqlite3* db) { sqlite3_close(db); };
    {
        // abrir una base de datos en memoria, y gestionar su ciclo de vida con std::unique_ptr
        std::unique_ptr<sqlite3, decltype(close_db)> up;
        sqlite3_open(":memory:", std::out_ptr(up));
        sqlite3* db = up.get();
        // hacer algo con db ...
    }
    {
        // igual que arriba, pero usando un std::shared_ptr
        std::shared_ptr<sqlite3> sp;
        sqlite3_open(":memory:", std::out_ptr(sp, close_db));
        sqlite3* db = sp.get();
        // hacer algo con db ...
    }
}

Véase también

(C++23)
crea un inout_ptr_t con un puntero inteligente asociado y argumentos de reinicio
(plantilla de función)
(C++14) (C++20)
crea un puntero único que gestiona un nuevo objeto
(plantilla de función)
(C++20)
crea un puntero compartido que gestiona un nuevo objeto
(plantilla de función)