unique_ptr, classe

Article
06/09/2015

Stocke un pointeur vers un objet détenu. L'objet n'est détenu par aucun autre unique_ptr. L'objet est détruit quand unique_ptr est détruit.

template< class Type, class Del = default_delete<Type> >
    class unique_ptr {
public:
    unique_ptr( );
    unique_ptr( nullptr_t Nptr );
    explicit unique_ptr( pointer Ptr );
    unique_ptr( pointer Ptr,
        typename conditional<is_reference<Del>::value, 
            Del,
            typename add_reference<const Del>::type>::type Deleter);
    unique_ptr (pointer Ptr,
        typename remove_reference<Del>::type&& Deleter);
    unique_ptr (unique_ptr&& Right);
    template<class Type2, Class Del2> unique_ptr( unique_ptr<Type2, Del2>&& Right );
    unique_ptr( const unique_ptr& Right) = delete;
    unique_ptr& operator=(const unique_ptr& Right ) = delete;
};

Paramètres

Right
unique_ptr
Nptr
rvalue de type std::nullptr_t.
Ptr
pointer
Deleter
Fonction deleter liée à un unique_ptr.

Exceptions

Aucune exception n'est générée par unique_ptr.

Notes

La classe unique_ptr remplace auto_ptr et peut être utilisée comme élément des conteneurs STL.

Utilisez la fonction d'assistance make_unique pour créer efficacement de nouvelles instances de unique_ptr.

unique_ptr gère de façon unique une ressource. Chaque objet unique_ptr stocke un pointeur vers l'objet qu'il possède ou stocke un pointeur null. Une ressource ne peut pas être détenue par plus d'un objet unique_ptr. Lorsque l'objet unique_ptr qui possède une ressource particulière est détruit, la ressource est libérée. Un objet unique_ptr peut être déplacé, mais pas copié. Pour plus d'informations, consultez Déclarateur de référence Rvalue : &&.

La ressource est libérée par l'appel à un objet deleter stocké de type Del qui sait comment les ressources sont allouées pour un unique_ptr particulier. L'objet deleter default_delete<Type> par défaut suppose que la ressource désignée par _Ptr est allouée à new, et qu'elle peut être libérée en appelant delete _Ptr. (Une spécialisation partielle unique_ptr<Type[]> gère les objets tableaux alloués à new[], et possède le deleter default_delete<Type[]> par défaut, spécialisé pour appeler delete[] _Ptr.)

Le pointeur stocké vers une ressource détenue, stored_ptr, a le type pointer. Il s'agit de Del::pointer s'il est défini, ou de Type * dans le cas contraire. L'objet deleter stocké stored_deleter n'occupe pas d'espace dans l'objet si le deleter est sans état. Notez que Del peut être un type référence.

Membres

Constructeurs

unique_ptr::unique_ptr

Il existe sept constructeurs pour unique_ptr.

Typedef

deleter_type	Synonyme pour le paramètre du modèle Del.
element_type	Synonyme pour le paramètre du modèle Type.
pointeur	Synonyme pour Del::pointer s'il est défini ; sinon Type *.

Fonctions membres

unique_ptr::get	Retourne stored_ptr.
unique_ptr::get_deleter	Retourne une référence à stored_deleter.
unique_ptr::release	Stocke pointer() dans stored_ptr et retourne son contenu précédent.
unique_ptr::reset	Libère la ressource détenue actuellement et accepte une nouvelle ressource.
unique_ptr::swap	Échange la ressource et deleter avec l'objet unique_ptr fourni.

Opérateurs

operator bool	L'opérateur retourne une valeur d'un type qui peut être converti en bool. Le résultat de la conversion en bool est true lorsque get() != pointer(), sinon false.
operator->	La fonction membre retourne stored_ptr.
operator*	La fonction membre retourne*stored_ptr.
unique_ptr operator=	Affecte la valeur d'un objet unique_ptr (ou un pointer-type) à l'objet unique_ptr actuel.

Configuration requise

En-tête : <memory>

Espace de noms : std

Voir aussi

Référence

Autres ressources

membres d'unique_ptr

Partager via