std:: inout_ptr_t

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

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

inout_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 de propriété.

Si Smart n'est pas un type pointeur, release ( ) est appelé au plus une fois sur l'objet adapté. Les implémentations peuvent appeler release ( ) dans le constructeur, ou avant la réinitialisation dans le destructeur si la valeur Pointer n'est pas nulle.

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 inout_ptr_t qui dépendent d'au moins un type défini par le programme ne sont pas tenues 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

inout_ptr_t s'attend à ce que les fonctions étrangères libèrent la propriété représentée par la valeur du Pointer pointé, puis la réinitialisent. Comme cette opération nécessite une propriété exclusive, l'utilisation avec std::shared_ptr est interdite.

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

if (int ec = foreign_resetter(std::inout_ptr(up)))
    return ec;

est approximativement équivalent à

T *raw_p = up.get();
up.release();
int ec = foreign_resetter(&raw_p);
up.reset(raw_p);
if (ec != 0)
    return ec;

Il n'est pas recommandé de créer un objet inout_ptr_t ayant une durée de stockage autre que la durée 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.

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