Comment fonctionne shared_ptr en C++?

shared_ptr — c'est un pointeur intelligent qui implémente la sémantique de propriété d'une ressource partagée. Il stocke un pointeur vers l'objet et un pointeur vers le bloc de contrôle.

Le bloc de contrôle contient :

Compteur de références fortes (reference count).
Compteur de références faibles (weak count).
Functor de suppression personnalisé (deleter), si spécifié.
Allocateur personnalisé, si spécifié.
Pointeur vers l'objet stocké (le même que celui stocké dans le shared_ptr).

Principe de fonctionnement :

Création : Lors de la création du premier shared_ptr pointant vers un objet, le bloc de contrôle est créé, et les compteurs de références sont initialisés : forts — 1, faibles — 0.
```
std::shared_ptr<int> ptr1 = std::make_shared<int>(10); // Crée un objet int et un bloc de contrôle
```
Copie : Lors de la copie d'un shared_ptr, le compteur de références fortes dans le bloc de contrôle augmente de 1.
```
std::shared_ptr<int> ptr2 = ptr1; // Augmente le compteur de références fortes
```
Assignation : Lors de l'assignation d'un shared_ptr, l'ancien ressource est décrémentée (le compteur de références fortes diminue), et la nouvelle ressource est incrémentée (augmente).
```
std::shared_ptr<int> ptr3;
ptr3 = ptr1; // Décrémente l'ancien ressource de ptr3, Incrémente la ressource de ptr1
```

Suppression : Lors de la destruction d'un shared_ptr (par exemple, sortie de portée), le compteur de références fortes est décrémenté.

{
    std::shared_ptr<int> ptr4 = ptr1; // Augmente le compteur de références fortes
    // ptr4 sort de la portée
} // Décrémente le compteur de références fortes

Libération de la ressource : Lorsque le compteur de références fortes atteint zéro, la ressource (l'objet pointé par shared_ptr) est supprimée en utilisant le functor de suppression défini (ou delete par défaut).
Libération du bloc de contrôle : Le bloc de contrôle est libéré lorsque les deux compteurs (forts et faibles) atteignent zéro.

Avantages :

Gestion automatique de la mémoire pour les ressources partagées.
Sécurité contre les double libérations.
Support pour les functors de suppression personnalisés.

Inconvénients :

Les références cycliques peuvent entraîner des fuites de mémoire (résolu avec weak_ptr).
Légère augmentation des coûts en raison du bloc de contrôle et des opérations atomiques sur les compteurs.
Sécurité dans les opérations avec le propre shared_ptr (copie, assignation, modification du pointeur stocké), mais pas avec l'objet pointé.