unique_ptr Class

Stocke un pointeur vers un objet possédé.L'objet est détenu par un autre unique_ptr.L'objet est détruit lorsque unique_ptr est détruit.

template<class Type, class Del = default_delete<Type> >
    class unique_ptr {

public:
        typedef Type element_type;
        typedef Del deleter_type;
        typedef T1 pointer;

        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 ();

    unique_ptr& operator= (
        unique_ptr&& _Right
    );
    template<class Type2, Class Del2>
        unique_ptr& operator= (
            unique_ptr<Type2, Del2>&& _Right
        );
    void swap (
        unique_ptr& _Right
    );
    pointer release ();
    void reset (
       pointer _Ptr = pointer()
    );

    pointer get () const;
    Type& operator* () const;
    pointer operator-> () const;
    Del& get_deleter ();
    const Del& get_deleter () const;
    explicit operator bool () const;

    unique_ptr(
        const unique_ptr& _Right
) = delete;
    unique_ptr& operator=(
        const unique_ptr& _Right
) = delete;

private:
    pointer stored_ptr;    // exposition only
    Del stored_deleter;    // exposition only
    };

Paramètres

• _Right
  unique_ptr

• _Nptr
  rvalue de type std::nullptr_t.

• _Ptr
  pointer

• _Deleter
  Une fonction d' deleter liée à unique_ptr.

Exceptions

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

Notes

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

unique_ptr gère uniquement une ressource.Chaque objet d' unique_ptr stocke un pointeur vers l'objet qu'il possède ou stocke un pointeur null.Une ressource peut être possédée par aucun plusieurs objets d' unique_ptr ; lorsqu'un objet d' unique_ptr qui possède une ressource particulière est détruit, la ressource est libérée.Un objet d' unique_ptr ne peut être déplacé, mais être copié ; pour plus d'informations, consultez Déclarateur de référence Rvalue : &&.

La ressource est libérée en appelant un objet stocké d' deleter du type Del capable de les ressources sont allouées pour unique_ptrparticulier.deleter par défaut default_delete<Type> suppose que la ressource pointée pointe vers _Ptr est allouée avec new, et qu'elle peut être libérée en appelant delete _Ptr.(La spécialisation partielle **unique_ptr<Type[]>**d'Un gère les objets alloués tableau avec new[], et un deleter par défaut default_delete<Type[]>, spécialisé pour appeler delete [] _Ptr.)

Le pointeur stocké dans une ressource propre, stored_ptr a le type pointer.C'est Del::pointer si est défini, et Type *cas contraire.L'objet stocké stored_deleter d' deleter n'occupe aucun espace dans l'objet si deleter est sans état.Notez qu' Del peut être un type référence.

Membres

Constructeurs

Typedef

Fonctions membres

Opérateurs

Configuration requise

En-tête : <memory>

L'espace de noms : DST

Voir aussi

Référence

<memory>

Autres ressources

membres d'unique_ptr