La classe unique_ptr

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

Syntaxe

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 T2, Class Del2>
    unique_ptr(unique_ptr<T2, Del2>&& Right);
    unique_ptr(const unique_ptr& Right) = delete;
    unique_ptr& operator=(const unique_ptr& Right) = delete;
};

//Specialization for arrays:
template <class T, class D>
class unique_ptr<T[], D> {
public:
    typedef pointer;
    typedef T element_type;
    typedef D deleter_type;
    constexpr unique_ptr() noexcept;
    template <class U>
    explicit unique_ptr(U p) noexcept;
    template <class U>
    unique_ptr(U p, see below d) noexcept;
    template <class U>
    unique_ptr(U p, see below d) noexcept;
    unique_ptr(unique_ptr&& u) noexcept;
    constexpr unique_ptr(nullptr_t) noexcept : unique_ptr() { }     template <class U, class E>
        unique_ptr(unique_ptr<U, E>&& u) noexcept;
    ~unique_ptr();
    unique_ptr& operator=(unique_ptr&& u) noexcept;
    template <class U, class E>
    unique_ptr& operator=(unique_ptr<U, E>&& u) noexcept;
    unique_ptr& operator=(nullptr_t) noexcept;
    T& operator[](size_t i) const;

    pointer get() const noexcept;
    deleter_type& get_deleter() noexcept;
    const deleter_type& get_deleter() const noexcept;
    explicit operator bool() const noexcept;
    pointer release() noexcept;
    void reset(pointer p = pointer()) noexcept;
    void reset(nullptr_t = nullptr) noexcept;
    template <class U>
    void reset(U p) noexcept = delete;
    void swap(unique_ptr& u) noexcept;  // disable copy from lvalue unique_ptr(const unique_ptr&) = delete;
    unique_ptr& operator=(const unique_ptr&) = 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 de bibliothèque standard C++.

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. Lorsqu’un objet unique_ptr qui possède une ressource particulière est détruit, la ressource est libérée. Un unique_ptr objet peut être déplacé, mais pas copié ; pour plus d’informations, consultez Rvalue Reference Declarator : &&.

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. La valeur par défaut deleter default_delete<T> suppose que la ressource pointée par ptr est allouée avec new, et qu’elle peut être libérée en appelant delete _Ptr. (Une spécialisation unique_ptr<T[]>partielle gère les objets de tableau alloués avec new[], et a la valeur par défaut deleter default_delete<T[]>, spécialisé pour appeler delete[] ptr.)

Le pointeur stocké vers une ressource détenue, stored_ptr, a le type pointer. Elle est si définie, et T * si ce n’est Del::pointer pas le cas. 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

Typedefs

Functions

Opérateurs

deleter_type

Le type est un synonyme du paramètre de modèle Del.

typedef Del deleter_type;

Notes

Le type est un synonyme du paramètre de modèle Del.

element_type

Le type est un synonyme du paramètre de modèle Type.

typedef Type element_type;

Notes

Le type est un synonyme du paramètre de modèle Ty.

get

Retourne stored_ptr.

pointer get() const;

Notes

La fonction membre retourne stored_ptr.

get_deleter

Retourne une référence à stored_deleter.

Del& get_deleter();

const Del& get_deleter() const;

Notes

La fonction membre retourne une référence à stored_deleter.

operator=

Affecte l'adresse du unique_ptr fourni à l'objet actif.

unique_ptr& operator=(unique_ptr&& right);
template <class U, Class Del2>
unique_ptr& operator=(unique_ptr<Type, Del>&& right);
unique_ptr& operator=(pointer-type);

Paramètres

Référence unique_ptr utilisée pour affecter la valeur au unique_ptr actif.

Notes

Les fonctions membres appellent reset(right.release()) et déplacent right.stored_deleter vers stored_deleter, puis retournent *this.

pointer

Synonyme pour Del::pointer s'il est défini ; sinon Type *.

typedef T1 pointer;

Notes

Le type est un synonyme de Del::pointer s'il est défini ; sinon Type *.

release

Libère la propriété du pointeur stocké retourné pour l'appelant et définit la valeur de pointeur stocké sur nullptr.

pointer release();

Notes

Utilisez release pour prendre possession du pointeur brut stocké par le pointeur unique_ptr. L'appelant est responsable de la suppression du pointeur retourné. Le pointeur unique-ptr est défini sur l'état construit par défaut vide. Vous pouvez affecter un autre pointeur de type compatible au pointeur unique_ptr après l'appel à release.

Exemple

Cet exemple montre comment l’appelant de release est responsable de l’objet retourné :

// stl_release_unique.cpp
// Compile by using: cl /W4 /EHsc stl_release_unique.cpp
#include <iostream>
#include <memory>

struct Sample {
   int content_;
   Sample(int content) : content_(content) {
      std::cout << "Constructing Sample(" << content_ << ")" << std::endl;
   }
   ~Sample() {
      std::cout << "Deleting Sample(" << content_ << ")" << std::endl;
   }
};

void ReleaseUniquePointer() {
   // Use make_unique function when possible.
   auto up1 = std::make_unique<Sample>(3);
   auto up2 = std::make_unique<Sample>(42);

   // Take over ownership from the unique_ptr up2 by using release
   auto ptr = up2.release();
   if (up2) {
      // This statement does not execute, because up2 is empty.
      std::cout << "up2 is not empty." << std::endl;
   }
   // We are now responsible for deletion of ptr.
   delete ptr;
   // up1 deletes its stored pointer when it goes out of scope.
}

int main() {
   ReleaseUniquePointer();
}

Constructing Sample(3)
Constructing Sample(42)
Deleting Sample(42)
Deleting Sample(3)

reset

Prend possession du paramètre de pointeur et supprime le pointeur stocké d'origine. Si le nouveau pointeur est le même que le pointeur d'origine stocké, reset supprime le pointeur et définit le pointeur stocké sur nullptr.

void reset(pointer ptr = pointer());
void reset(nullptr_t ptr);

Paramètres

ptr
Pointeur vers la ressource dont il faut prendre possession.

Notes

Permet reset de modifier le stockage détenu pointer par le unique_ptr ptr , puis de supprimer le pointeur stocké d’origine. Si ce unique_ptr n’était pas vide, reset appelle la fonction deleter retournée par get_deleter le pointeur stocké d’origine.

Étant donné que reset le nouveau pointeur stocke le nouveau pointeur ptr, puis supprime le pointeur stocké d’origine, il est possible de reset supprimer ptr immédiatement s’il est identique au pointeur stocké d’origine.

swap

Échange des pointeurs entre deux objets unique_ptr.

void swap(unique_ptr& right);

Paramètres

right
unique_ptr utilisé pour échanger des pointeurs.

Notes

La fonction membre échange stored_ptr avec right.stored_ptr et stored_deleter avec right.stored_deleter.

unique_ptr

Il existe sept constructeurs pour unique_ptr.

unique_ptr();

unique_ptr(nullptr_t);
explicit unique_ptr(pointer ptr);

unique_ptr(
    Type* 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 Ty2, Class Del2>
    unique_ptr(unique_ptr<Ty2, Del2>&& right);

Paramètres

ptr
Pointeur vers la ressource à affecter à un unique_ptr.

_Deleter
deleter à affecter à un unique_ptr.

right
rvalue reference à un unique_ptr à partir duquel des champs unique_ptr sont affectés par déplacement au unique_ptr nouvellement construit.

Notes

Les deux premiers constructeurs construisent un objet qui ne gère aucune ressource. Le troisième constructeur stocke ptr dans stored_ptr. Le quatrième constructeur stocke ptr dans stored_ptr et deleter dans stored_deleter.

Le cinquième constructeur stocke ptr dans stored_ptr et déplace deleter dans stored_deleter. Les sixième et septième constructeurs stockent right.release() dans stored_ptr et déplacent right.get_deleter() dans stored_deleter.

~unique_ptr

Destructeur de unique_ptr. Détruit un objet unique_ptr.

~unique_ptr();

Notes

Le destructeur appelle get_deleter()(stored_ptr).