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
| Nom | Description |
|---|---|
unique_ptr |
Il existe sept constructeurs pour unique_ptr. |
Typedefs
| Nom | Description |
|---|---|
deleter_type |
Synonyme pour le paramètre du modèle Del. |
element_type |
Synonyme pour le paramètre du modèle T. |
pointer |
Synonyme pour Del::pointer s'il est défini ; sinon T *. |
Functions
| Nom | Description |
|---|---|
get |
Retourne stored_ptr. |
get_deleter |
Retourne une référence à stored_deleter. |
release |
Stocke pointer() dans stored_ptr et retourne son contenu précédent. |
reset |
Libère la ressource détenue actuellement et accepte une nouvelle ressource. |
swap |
Échange la ressource et deleter avec l'objet unique_ptr fourni. |
Opérateurs
| Nom | Description |
|---|---|
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. |
operator= |
Assigne la valeur d’un objet unique_ptr (ou d’un pointer-type) à l’objet unique_ptr actuel. |
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).