unique_ptr, classeunique_ptr Class

Stocke un pointeur vers un objet ou un tableau détenu.Stores a pointer to an owned object or array. L'objet/tableau n'est détenu par aucun autre unique_ptr.The object/array is owned by no other unique_ptr. L'objet/tableau est détruit quand unique_ptr est détruit.The object/array is destroyed when the unique_ptr is destroyed.

SyntaxeSyntax

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ètresParameters

DroiteRight
unique_ptrA unique_ptr.

NptrNptr
rvalue de type std::nullptr_t.An rvalue of type std::nullptr_t.

PTRPtr
pointerA pointer.

SUPPRESSEURDeleter
Fonction deleter liée à un unique_ptr.A deleter function that is bound to a unique_ptr.

ExceptionsExceptions

Aucune exception n'est générée par unique_ptr.No exceptions are generated by unique_ptr.

NotesRemarks

La classe unique_ptr remplace auto_ptr et peut être utilisée comme élément des conteneurs de bibliothèque standard C++.The unique_ptr class supersedes auto_ptr, and can be used as an element of C++ Standard Library containers.

Utilisez la fonction d’assistance make_unique pour créer efficacement de nouvelles instances de unique_ptr.Use the make_unique helper function to efficiently create new instances of unique_ptr.

unique_ptr gère de façon unique une ressource.unique_ptr uniquely manages a resource. Chaque objet unique_ptr stocke un pointeur vers l'objet qu'il possède ou stocke un pointeur null.Each unique_ptr object stores a pointer to the object that it owns or stores a null pointer. 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.A resource can be owned by no more than one unique_ptr object; when a unique_ptr object that owns a particular resource is destroyed, the resource is freed. Un objet unique_ptr peut être déplacé, mais pas copié. Pour plus d’informations, consultez Déclarateur de référence Rvalue : &&.A unique_ptr object may be moved, but not copied; for more information, see 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.The resource is freed by calling a stored deleter object of type Del that knows how resources are allocated for a particular unique_ptr. La valeur par défaut deleter default_delete<T> suppose que la ressource désignée par ptr est alloué avec new, et qu’elle peut être libérée en appelant delete _Ptr.The default deleter default_delete<T> assumes that the resource pointed to by ptr is allocated with new, and that it can be freed by calling delete _Ptr. (Une spécialisation partielle unique_ptr<T[]> gère les objets tableaux alloués à new[], et possède le deleter default_delete<T[]> par défaut, spécialisé pour appeler delete[] ptr.)(A partial specialization unique_ptr<T[]>manages array objects allocated with new[], and has the default deleter default_delete<T[]>, specialized to call delete[] ptr.)

Le pointeur stocké vers une ressource détenue, stored_ptr, a le type pointer.The stored pointer to an owned resource, stored_ptr has type pointer. Il s’agit de Del::pointer s’il est défini, ou de T * dans le cas contraire.It is Del::pointer if defined, and T * if not. L'objet deleter stocké stored_deleter n'occupe pas d'espace dans l'objet si le deleter est sans état.The stored deleter object stored_deleter occupies no space in the object if the deleter is stateless. Notez que Del peut être un type référence.Note that Del can be a reference type.

MembresMembers

ConstructeursConstructors

ConstructeurConstructor DescriptionDescription
unique_ptrunique_ptr Il existe sept constructeurs pour unique_ptr.There are seven constructors for unique_ptr.

TypedefTypedefs

Nom de typeType name DescriptionDescription
deleter_typedeleter_type Synonyme pour le paramètre du modèle Del.A synonym for the template parameter Del.
element_typeelement_type Synonyme pour le paramètre du modèle T.A synonym for the template parameter T.
pointerpointer Synonyme pour Del::pointer s'il est défini ; sinon T *.A synonym for Del::pointer if defined, otherwise T *.

Fonctions membresMember functions

Fonction membreMember function DescriptionDescription
getget Retourne stored_ptr.Returns stored_ptr.
get_deleterget_deleter Retourne une référence à stored_deleter.Returns a reference to stored_deleter.
releaserelease Stocke pointer() dans stored_ptr et retourne son contenu précédent.stores pointer() in stored_ptr and returns its previous contents.
resetreset Libère la ressource détenue actuellement et accepte une nouvelle ressource.Releases the currently owned resource and accepts a new resource.
swapswap Échange la ressource et deleter avec l'objet unique_ptr fourni.Exchanges resource and deleter with the provided unique_ptr.

OpérateursOperators

OpérateurOperator DescriptionDescription
operator booloperator bool L’opérateur retourne une valeur d’un type convertible en bool.The operator returns a value of a type that is convertible to bool. Le résultat de la conversion en bool est true lorsque get() != pointer(), sinon false.The result of the conversion to bool is true when get() != pointer(), otherwise false.
operator-> La fonction membre retourne stored_ptr.The member function returns stored_ptr.
operator* La fonction membre retourne *stored_ptr.The member function returns *stored_ptr.
unique_ptr operator=unique_ptr operator= Assigne la valeur d’un objet unique_ptr (ou d’un pointer-type) à l’objet unique_ptr actuel.Assigns the value of a unique_ptr (or a pointer-type) to the current unique_ptr.

Configuration requiseRequirements

En-tête : <memory>Header: <memory>

Espace de noms : stdNamespace: std

deleter_typedeleter_type

Le type est un synonyme du paramètre de modèle Del.The type is a synonym for the template parameter Del.

typedef Del deleter_type;

NotesRemarks

Le type est un synonyme du paramètre de modèle Del.The type is a synonym for the template parameter Del.

element_typeelement_type

Le type est un synonyme du paramètre de modèle Type.The type is a synonym for the template parameter Type.

typedef Type element_type;

NotesRemarks

Le type est un synonyme du paramètre de modèle Ty.The type is a synonym for the template parameter Ty.

unique_ptr::getunique_ptr::get

Retourne stored_ptr.Returns stored_ptr.

pointer get() const;

NotesRemarks

La fonction membre retourne stored_ptr.The member function returns stored_ptr.

unique_ptr::get_deleterunique_ptr::get_deleter

Retourne une référence à stored_deleter.Returns a reference to stored_deleter.

Del& get_deleter();

const Del& get_deleter() const;

NotesRemarks

La fonction membre retourne une référence à stored_deleter.The member function returns a reference to stored_deleter.

unique_ptr operator=unique_ptr operator=

Affecte l'adresse du unique_ptr fourni à l'objet actif.Assigns the address of the provided unique_ptr to the current one.

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ètresParameters

Référence unique_ptr utilisée pour affecter la valeur au unique_ptr actif.A unique_ptr reference used to assign the value of to the current unique_ptr.

NotesRemarks

Les fonctions membres appellent reset(right.release()) et déplacent right.stored_deleter vers stored_deleter, puis retournent *this.The member functions call reset(right.release()) and move right.stored_deleter to stored_deleter, then return *this.

pointerpointer

Synonyme pour Del::pointer s'il est défini ; sinon Type *.A synonym for Del::pointer if defined, otherwise Type *.

typedef T1 pointer;

NotesRemarks

Le type est un synonyme de Del::pointer s'il est défini ; sinon Type *.The type is a synonym for Del::pointer if defined, otherwise Type *.

unique_ptr::releaseunique_ptr::release

Libère la propriété du pointeur stocké retourné à l’appelant et définit la valeur de pointeur stocké sur nullptr.Releases ownership of the returned stored pointer to the caller and sets the stored pointer value to nullptr.

pointer release();

NotesRemarks

Utilisez release pour prendre possession du pointeur brut stocké par le pointeur unique_ptr.Use release to take over ownership of the raw pointer stored by the unique_ptr. L'appelant est responsable de la suppression du pointeur retourné.The caller is responsible for deletion of the returned pointer. Le pointeur unique-ptr est défini sur l'état construit par défaut vide.The unique-ptr is set to the empty default-constructed state. Vous pouvez affecter un autre pointeur de type compatible au pointeur unique_ptr après l'appel à release.You can assign another pointer of compatible type to the unique_ptr after the call to release.

ExempleExample

Cet exemple montre comment l’appelant de release est responsable de l’objet retourné :This example shows how the caller of release is responsible for the object returned:

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

Sortie de l'ordinateur :Computer output:

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

unique_ptr::resetunique_ptr::reset

Prend possession du paramètre de pointeur et supprime le pointeur stocké d'origine.Takes ownership of the pointer parameter, and then deletes the original stored pointer. Si le nouveau pointeur est le même que le pointeur stocké d’origine, reset supprime le pointeur et définit le pointeur stocké sur nullptr.If the new pointer is the same as the original stored pointer, reset deletes the pointer and sets the stored pointer to nullptr.

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

ParamètresParameters

ParamètreParameter DescriptionDescription
ptrptr Pointeur vers la ressource dont il faut prendre possession.A pointer to the resource to take ownership of.

NotesRemarks

Utilisez reset pour attribuer au pointeur détenus par le unique_ptr à ptr , puis supprimez le pointeur stocké d’origine.Use reset to change the stored pointer owned by the unique_ptr to ptr and then delete the original stored pointer. Si l’objet unique_ptr n’était pas vide, reset appelle la fonction de suppression retournée par get_deleter sur le pointeur stocké d’origine.If the unique_ptr was not empty, reset invokes the deleter function returned by get_deleter on the original stored pointer.

Étant donné que reset stocke tout d’abord le nouveau pointeur ptr, puis supprime le pointeur stocké d’origine, il est possible pour reset supprimer immédiatement ptr si elle est identique à l’original pointeur stocké.Because reset first stores the new pointer ptr, and then deletes the original stored pointer, it's possible for reset to immediately delete ptr if it is the same as the original stored pointer.

unique_ptr::swapunique_ptr::swap

Échange des pointeurs entre deux objets unique_ptr.Exchanges pointers between two unique_ptr objects.

void swap(unique_ptr& right);

ParamètresParameters

rightright
unique_ptr utilisé pour échanger des pointeurs.A unique_ptr used to swap pointers.

NotesRemarks

La fonction membre échange stored_ptr avec right.stored_ptr et stored_deleter avec right.stored_deleter.The member function swaps stored_ptr with right.stored_ptr and stored_deleter with right.stored_deleter.

unique_ptr::unique_ptrunique_ptr::unique_ptr

Il existe sept constructeurs pour unique_ptr.There are seven constructors for 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ètresParameters

ParamètreParameter DescriptionDescription
ptrptr Pointeur vers la ressource à affecter à un unique_ptr.A pointer to the resource to be assigned to a unique_ptr.
_Deleter_Deleter deleter à affecter à un unique_ptr.A deleter to be assigned to a unique_ptr.
rightright rvalue reference à un unique_ptr à partir duquel des champs unique_ptr sont affectés par déplacement au unique_ptr nouvellement construit.An rvalue reference to a unique_ptr from which unique_ptr fields are move assigned to the newly constructed unique_ptr.

NotesRemarks

Les deux premiers constructeurs construisent un objet qui ne gère aucune ressource.The first two constructors construct an object that manages no resource. Le troisième constructeur stocke ptr dans stored_ptr.The third constructor stores ptr in stored_ptr. Le quatrième constructeur stocke ptr dans stored_ptr et deleter dans stored_deleter.The fourth constructor stores ptr in stored_ptr and deleter in stored_deleter.

Le cinquième constructeur stocke ptr dans stored_ptr et déplace deleter dans stored_deleter.The fifth constructor stores ptr in stored_ptr and moves deleter into stored_deleter. Les sixième et septième constructeurs stockent right.release() dans stored_ptr et déplacent right.get_deleter() dans stored_deleter.The sixth and seventh constructors store right.release() in stored_ptr and moves right.get_deleter() into stored_deleter.

unique_ptr ~unique_ptrunique_ptr ~unique_ptr

Destructeur de unique_ptr. Détruit un objet unique_ptr.The destructor for unique_ptr, destroys a unique_ptr object.

~unique_ptr();

NotesRemarks

Le destructeur appelle get_deleter()(stored_ptr).The destructor calls get_deleter()(stored_ptr).

Voir aussiSee also

<memory><memory>