std::unique_ptr est un pointeur intelligent introduit en C++11. Il gère automatiquement les ressources allouées dynamiquement sur le tas. Les pointeurs intelligents ne sont que des enveloppes autour d'anciens pointeurs classiques qui vous aident à éviter les bogues généralisés. À savoir, oublier de supprimer un pointeur et provoquer une fuite de mémoire ou supprimer accidentellement un pointeur deux fois ou de la mauvaise manière. Ils peuvent être utilisés de la même manière que les pointeurs standards. Ils automatisent certains des processus manuels qui provoquent des bugs courants.
Conditions préalables: Pointeur en C++ , Pointeurs intelligents en C++.
Syntaxe
unique_ptr< A>ptr1 (nouveau A )>
Ici,
- unique_ptr : Il spécifie le type de std::unique_ptr. Dans ce cas- un objet de type A.
- nouveau A : Un objet de type A est alloué dynamiquement sur le tas à l'aide de l'opérateur new.
- ptr1 : C'est le nom de la variable std::unique_ptr.
Que se passe-t-il lorsque unique_ptr est utilisé ?
Quand on écrit unique_ptr ptr1 (nouveau A), la mémoire est allouée sur le tas pour une instance du type de données A. ptr1 est initialisé et pointe vers l'objet A nouvellement créé. Ici, ptr1 est le seul propriétaire de l’objet A nouvellement créé et gère la durée de vie de cet objet. Cela signifie que lorsque ptr1 est réinitialisé ou sort de la portée, la mémoire est automatiquement libérée et l'objet de A est détruit.
Quand utiliser unique_ptr ?
Lorsque la propriété de la ressource est requise. Lorsque nous souhaitons la propriété unique ou exclusive d’une ressource, nous devons alors opter pour des pointeurs uniques. Un seul pointeur unique peut pointer vers une ressource. Ainsi, un pointeur unique ne peut pas être copié sur un autre. En outre, il facilite le nettoyage automatique lorsque les objets alloués dynamiquement sont hors de portée et aide à prévenir les fuites de mémoire.
Remarque : nous devons utiliser le fichier d’en-tête pour utiliser ces pointeurs intelligents.
Exemples de Unique_ptr
Exemple 1:
Créons une structure A et elle aura une méthode nommée printA pour afficher du texte. Ensuite, dans la section principale, créons un pointeur unique qui pointera vers la structure A. Donc à ce stade, nous avons une instance de la structure A et p1 contient le pointeur vers celle-ci.
C++
// C++ Program to implement unique_ptr> #include> #include> using> namespace> std;> > struct> A {> >void> printA() { cout <<>'A struct....'> << endl; }> };> > int> main()> {> >unique_ptr p1(> new> A);> >p1->printA();> > >// displays address of the containing pointer> >cout << p1.get() << endl;> >return> 0;> }> |
comment trouver des applications cachées sur Android
>
>Sortir
tri par insertion Java
A struct.... 0x18dac20>
Exemple 2
Créons maintenant un autre pointeur p2 et nous allons essayer de copier le pointeur p1 en utilisant l'opérateur d'affectation (=).
C++
// C++ Program to implement unique_ptr> #include> #include> using> namespace> std;> > struct> A {> >void> printA() { cout <<>'A struct....'> << endl; }> };> int> main()> {> >unique_ptr p1(> new> A);> >p1->printA();> > >// displays address of the containing pointer> >cout << p1.get() << endl;> > >// will give compile time error> >unique_ptr> p2 = p1;> >p2->printA();> >return> 0;> }> |
>
>
Sortir
main.cpp: In function ‘int main()’: main.cpp:18:24: error: use of deleted function ‘std::unique_ptr::unique_ptr(const std::unique_ptr&) [with _Tp = A; _Dp = std::default_delete]’ 18 | unique_ptr p2 = p1; | ^~ In file included from /usr/include/c++/11/memory:76, from main.cpp:3: /usr/include/c++/11/bits/unique_ptr.h:468:7: note: declared here 468 | unique_ptr(const unique_ptr&) = delete; | ^~~~~~~~~~>
Le code ci-dessus donnera une erreur de compilation car nous ne pouvons pas attribuer le pointeur p2 à p1 en cas de pointeurs uniques. Nous devons utiliser la sémantique de déplacement à ces fins, comme indiqué ci-dessous.
fonctions en c
Exemple 3
Gestion d'un objet de type A à l'aide de la sémantique de déplacement.
C++
// C++ Program to implement unique_ptr> #include> #include> using> namespace> std;> > struct> A {> >void> printA() { cout <<>'A struct....'> << endl; }> };> int> main()> {> >unique_ptr p1(> new> A);> >p1->printA();> > >// displays address of the containing pointer> >cout << p1.get() << endl;> > >// now address stored in p1 shpould get copied to p2> >unique_ptr> p2 = move(p1);> > >p2->printA();> >cout << p1.get() << endl;> >cout << p2.get() << endl;> >return> 0;> }> |
>
>Sortir
A struct.... 0x2018c20 A struct.... 0 0x2018c20>
Notez qu'une fois l'adresse du pointeur p1 copiée vers le pointeur p2, l'adresse du pointeur p1 devient NULL(0) et l'adresse stockée par p2 est maintenant la même que l'adresse stockée par p1, montrant que l'adresse dans p1 a été transférée au pointeur. p2 en utilisant la sémantique de déplacement.