std:: out_ptr_t

out_ptr_t est utilisé pour adapter des types tels que les pointeurs intelligents pour des fonctions externes qui produisent leurs résultats via un paramètre Pointer* (généralement T** pour un type d'objet T ) ou un paramètre void ** .

out_ptr_t capture des arguments supplémentaires lors de sa construction, fournit un stockage pour le résultat auquel une telle fonction étrangère susmentionnée écrit, et finalement réinitialise l'objet Smart adapté avec le résultat et les arguments capturés lorsqu'il est détruit.

out_ptr_t se comporte comme s'il contenait les membres de données non statiques suivants :

• une référence Smart& , qui est liée à l'objet adapté lors de la construction,
• pour chaque T dans Args... , un membre de type T , qui est un argument capturé lors de la construction et utilisé pour la réinitialisation lors de la destruction, et
• un sous-objet membre adapté au stockage d'un Pointer et fournissant un objet void * , où le Pointer ou l'objet void * est généralement exposé à une fonction externe pour la réinitialisation.

Les utilisateurs peuvent contrôler si chaque argument pour la réinitialisation est capturé par copie ou par référence, en spécifiant un type d'objet ou un type de référence dans Args... respectivement.

Paramètres du modèle

Spécialisations

Contrairement à la plupart des modèles de classe dans la bibliothèque standard, les spécialisations définies par le programme de out_ptr_t qui dépendent d'au moins un type défini par le programme n'ont pas besoin de satisfaire aux exigences du modèle principal.

Cette licence permet à une spécialisation définie par le programme d'exposer le pointeur brut stocké dans un pointeur intelligent non standard à des fonctions externes.

Fonctions membres

Fonctions non membres

Notes

out_ptr_t s'attend à ce que les fonctions étrangères n'utilisent pas la valeur du pointeur Pointer , et seulement le réinitialisent. La valeur du pointeur intelligent avant l'adaptation n'est pas utilisée.

L'utilisation typique de out_ptr_t consiste à créer ses objets temporaires via std::out_ptr , ce qui réinitialise immédiatement le pointeur intelligent adapté. Par exemple, étant donnée une fonction mutatrice et un pointeur intelligent de type approprié déclarés avec int foreign_setter ( T ** ) ; et std:: unique_ptr < T, D > up ; respectivement,

int foreign_setter(T**);
std::unique_ptr<T, D> up;
if (int ec = foreign_setter(std::out_ptr(up)))
    return ec;

est approximativement équivalent à

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;

` et contient des termes spécifiques au C++ qui doivent être préservés. La structure HTML et les attributs ont été maintenus intacts conformément aux instructions.

Il n'est pas recommandé de créer un objet out_ptr_t ayant une durée de stockage autre que la durée de stockage automatique, car un tel code est susceptible de produire des références pendantes et d'entraîner un comportement indéfini lors de la destruction.

out_ptr_t interdit l'utilisation qui réinitialiserait un std::shared_ptr sans spécifier un suppresseur, car cela appellerait std::shared_ptr::reset et remplacerait ultérieurement un suppresseur personnalisé.

Les arguments capturés sont généralement regroupés dans un std:: tuple < Args... > . Les implémentations peuvent utiliser différents mécanismes pour fournir l'objet Pointer ou void * qu'elles doivent contenir.

Exemple

Voir aussi