shared_ptr et weak_ptr : propriété partagée
Partager la propriété avec le comptage de références et rompre les cycles avec weak_ptr
shared_ptr et weak_ptr : propriété partagée est une leçon C++ Academy gratuite sur CoddyKit. Ceci est la leçon 3 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.
Partager un objet
Il arrive que plusieurs parties du programme doivent maintenir un objet en vie. std::shared_ptr<T> gère la propriété partagée grâce au comptage des références.
Créer un shared_ptr
Utilisez std::make_shared : cette fonction alloue le bloc de contrôle et l’objet en une seule allocation.
#include <memory>
auto s = std::make_shared<Widget>(42);
std::cout << s.use_count(); // 1La copie partage la propriété
Copier un shared_ptr augmente le comptage des références. Le détruire ou lui attribuer une autre valeur le diminue. Lorsque le compteur atteint 0, l’objet est supprimé.
auto a = std::make_shared<Widget>();
auto b = a; // ref count is now 2
std::cout << a.use_count(); // 2Fonctionnement interne
Un shared_ptr contient deux pointeurs : l’un vers l’objet, l’autre vers un bloc de contrôle contenant le ou les comptages de références. Le bloc de contrôle est alloué sur le tas.
Comptage atomique des références
Le comptage des références utilise des opérations atomiques afin que les objets shared_ptr puissent être copiés entre fils d’exécution en toute sécurité. Cependant, l’objet pointé lui-même n’est pas automatiquement sûr pour les fils d’exécution.
Réinitialiser et réattribuer
L’attribution d’une nouvelle valeur diminue l’ancien comptage des références et augmente le nouveau. reset() réinitialise le shared_ptr pour qu’il soit vide.
shared_ptr depuis un pointeur brut (à éviter)
Ne construisez pas deux shared_ptr à partir du même pointeur brut : chacun aurait son propre bloc de contrôle. Utilisez toujours make_shared.
// BUG
Widget* raw = new Widget();
std::shared_ptr<Widget> a(raw);
std::shared_ptr<Widget> b(raw); // disaster: two control blocksLe problème des cycles
Deux shared_ptr qui se référencent mutuellement forment un cycle : le compteur de références d’aucun des deux n’atteint zéro, et aucun n’est libéré. Cela provoque une fuite mémoire.
struct Node {
std::shared_ptr<Node> next;
};
auto a = std::make_shared<Node>();
auto b = std::make_shared<Node>();
a->next = b;
b->next = a; // cycle — never freedRompre les cycles avec weak_ptr
std::weak_ptr<T> observe un shared_ptr sans participer au compteur de références. Rendez faible un côté de la relation pour rompre le cycle.
struct Node {
std::shared_ptr<Node> next;
std::weak_ptr<Node> prev; // weak — does not own
};Utiliser weak_ptr
Vous ne pouvez pas déréférencer directement un weak_ptr. Appelez lock() pour obtenir un shared_ptr, ou un pointeur vide si l’objet a été détruit.
std::weak_ptr<Widget> w = sharedPtr;
if (auto p = w.lock()) {
p->use(); // safe — we have a shared_ptr now
} else {
std::cout << "object expired";
}Coût comparé à unique_ptr
shared_ptr est plus volumineux (deux pointeurs et un bloc de contrôle) et plus lent (compteur de références atomique). Utilisez-le uniquement lorsque la propriété doit réellement être partagée.
Vérification rapide
Quel est le cas d’utilisation habituel de std::weak_ptr ?
Récapitulatif
shared_ptr suit la propriété au moyen d’un compteur de références atomique. Utilisez make_shared, méfiez-vous des cycles et rompez-les avec weak_ptr. Préférez unique_ptr lorsque le partage n’est pas nécessaire.
Questions Fréquemment Posées
La leçon « shared_ptr et weak_ptr : propriété partagée » est-elle gratuite ?
Oui — le texte complet de « shared_ptr et weak_ptr : propriété partagée » 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 « shared_ptr et weak_ptr : propriété partagée » ?
Partager la propriété avec le comptage de références et rompre les cycles avec weak_ptr 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 3 sur 4.
Combien de temps prend la leçon « shared_ptr et weak_ptr : propriété partagée » ?
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
- Pourquoi les pointeurs intelligents remplacent new et delete bruts
- unique_ptr : propriété exclusive
- shared_ptr et weak_ptr : propriété partagée
- Suppresseurs personnalisés et fonctions make