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
Défini dans l'en-tête <memory>
template < class Pointer = void , class Smart, class ... Args >
auto out_ptr ( Smart & s, Args && ... args ) ;
(depuis C++23)

Retourne un std::out_ptr_t avec des arguments de template déduits qui capture les arguments pour la réinitialisation par référence.

Le programme est mal formé si la construction de la valeur de retour (voir ci-dessous) est mal formée.

Table des matières

Paramètres

s - l'objet (généralement un pointeur intelligent) à adapter
args... - les arguments de réinitialisation à capturer

Valeur de retour

std:: out_ptr_t < Smart, P, Args && > ( s, std:: forward < Args > ( args ) ... ) , où P est

  • Pointer , si Pointer n'est pas un type void . Sinon,
  • Smart :: pointer , s'il est valide et désigne un type. Sinon,
  • Smart :: element_type * , si Smart :: element_type est valide et désigne un type. Sinon,
  • std:: pointer_traits < Smart > :: element_type * .

Notes

Les utilisateurs peuvent spécifier l'argument template pour le paramètre template Pointer , afin d'interagir avec des fonctions externes qui prennent un Pointer * .

Comme tous les arguments pour la réinitialisation sont capturés par référence, le out_ptr_t retourné doit être un objet temporaire détruit à la fin de l'expression complète contenant l'appel à la fonction externe, afin d'éviter les références pendantes.

Macro de test de fonctionnalité Valeur Norme Fonctionnalité
__cpp_lib_out_ptr 202106L (C++23) std::out_ptr , std::inout_ptr
202311L (C++26) version autonome de std::out_ptr et std::inout_ptr

Exemple

Utilisez std::out_ptr pour adapter un pointeur intelligent pour sqlite3_open , qui attend un sqlite3** comme paramètre de sortie.

Exécuter ce code 
#include <memory>
#include <sqlite3.h>
int main()
{
    auto close_db = [](sqlite3* db) { sqlite3_close(db); };
    {
        // open an in-memory database, and manage its lifetime with std::unique_ptr
        std::unique_ptr<sqlite3, decltype(close_db)> up;
        sqlite3_open(":memory:", std::out_ptr(up));
        sqlite3* db = up.get();
        // do something with db ...
    }
    {
        // same as above, but use a std::shared_ptr
        std::shared_ptr<sqlite3> sp;
        sqlite3_open(":memory:", std::out_ptr(sp, close_db));
        sqlite3* db = sp.get();
        // do something with db ...
    }
}

Voir aussi

(C++23)
crée un inout_ptr_t avec un pointeur intelligent associé et des arguments de réinitialisation
(modèle de fonction)
(C++14) (C++20)
crée un pointeur unique qui gère un nouvel objet
(modèle de fonction)
(C++20)
crée un pointeur partagé qui gère un nouvel objet
(modèle de fonction)