0Pricing
C++ Academy · Leçon

unique_ptr : propriété exclusive

Exprimer une sémantique de propriétaire unique avec unique_ptr et des types uniquement déplaçables

unique_ptr : propriété exclusive est une leçon C++ Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage C++ Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours C++ Academy comprend 4 leçons au total.

Le pointeur intelligent à propriétaire unique

std::unique_ptr<T> possède un objet du tas. Lorsque le unique_ptr est détruit, il supprime l’objet. Il ne peut pas être copié, uniquement déplacé.

Créer un unique_ptr

Utilisez std::make_unique (C++14) : cette fonction est sûre en présence d’exceptions et concise.

#include <memory>
auto w = std::make_unique<Widget>();         // default-constructed
auto p = std::make_unique<Point>(3, 4);       // forwarded args

L’utiliser comme un pointeur

unique_ptr prend en charge les opérations habituelles sur les pointeurs.

auto p = std::make_unique<Point>(3, 4);
std::cout << p->x;        // arrow access
std::cout << (*p).y;      // dereference
if (p) std::cout << "non-null";

Copie impossible — déplacement possible

La copie créerait deux propriétaires, ce qui violerait le principe d’unicité. Le déplacement transfère la propriété.

std::unique_ptr<int> a = std::make_unique<int>(1);
std::unique_ptr<int> b = std::move(a);
// a is now empty, b owns the int

Le transmettre à des fonctions

Par valeur (avec std::move) : transférez la propriété. Par référence : empruntez l’objet sans en être propriétaire.

void consume(std::unique_ptr<Widget> w);   // takes ownership
void inspect(const Widget& w);              // borrows

auto w = std::make_unique<Widget>();
consume(std::move(w));
// w is now empty
inspect(*w);                                // (after re-creating)

Le renvoyer depuis des fonctions

Une fonction qui alloue un objet et en renvoie la propriété doit renvoyer un std::unique_ptr.

std::unique_ptr<Widget> create() {
    return std::make_unique<Widget>();
}

Réinitialiser et libérer

reset() supprime l’objet actuel et prend éventuellement la propriété d’un nouvel objet. release() abandonne la propriété et renvoie le pointeur brut.

auto p = std::make_unique<int>(10);
p.reset(new int(20));    // delete the old, own the new
int* raw = p.release();   // p is now empty
delete raw;               // caller must delete

get() : emprunter le pointeur brut

get() renvoie le pointeur brut sans abandonner la propriété. Utilisez-le pour une interopérabilité sans propriété.

auto p = std::make_unique<int>(42);
legacy_api(p.get());      // p still owns it

unique_ptr vers des tableaux

Pour les tableaux, utilisez unique_ptr<T[]>. L’accès indexé se fait avec [] ; delete[] est appelé lors de la destruction.

auto arr = std::make_unique<int[]>(10);
arr[0] = 99;
std::cout << arr[0];

Suppresseurs personnalisés

Fournissez un suppresseur personnalisé comme paramètre de modèle lorsque la ressource n’est pas de la mémoire brute (descripteurs de fichiers, ressources de l’OS).

auto closer = [](FILE* f) { if (f) std::fclose(f); };
std::unique_ptr<FILE, decltype(closer)> file(std::fopen("a.txt","r"), closer);

Performances

Avec le suppresseur par défaut, unique_ptr a la même taille et la même vitesse qu’un pointeur brut, sans aucun surcoût.

Vérification rapide

Pourquoi std::unique_ptr interdit-il la copie ?

Récapitulatif

std::unique_ptr est le pointeur intelligent par défaut : aucun surcoût, propriété exclusive, déplaçable mais non copiable. Préférez std::make_unique pour sa construction.

Questions Fréquemment Posées

La leçon « unique_ptr : propriété exclusive » est-elle gratuite ?

Oui — le texte complet de « unique_ptr : propriété exclusive » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours C++ Academy, passe à CoddyKit PRO. Le cours C++ Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « unique_ptr : propriété exclusive » ?

Exprimer une sémantique de propriétaire unique avec unique_ptr et des types uniquement déplaçables Tu pratiques C++ Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer C++ Academy ?

Aucune expérience préalable n'est requise. C++ Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « unique_ptr : propriété exclusive » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon C++ Academy ?

Oui. Chaque leçon C++ Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

  1. Pourquoi les pointeurs intelligents remplacent new et delete bruts
  2. unique_ptr : propriété exclusive
  3. shared_ptr et weak_ptr : propriété partagée
  4. Suppresseurs personnalisés et fonctions make
← Retour à C++ Academy