Quels sont les pointeurs intelligents en C++?

std::unique_ptr, std::shared_ptr, std::weak_ptr.

std::unique_ptr:
- Propriété exclusive de l'objet.
- Ne peut pas être copié, mais peut être déplacé (std::move).
- Supprime automatiquement l'objet à la sortie du scope ou lors de la destruction de unique_ptr.
- Léger, sans coûts supplémentaires pour le compteur de références.
```
#include <memory>

// Création de unique_ptr
std::unique_ptr<int> up1(new int(10));

// Déplacement de propriété
std::unique_ptr<int> up2 = std::move(up1);

// up1 est maintenant nullptr
// up2 possède l'objet
```
std::shared_ptr:
- Propriété partagée de l'objet.
- Utilise un compteur de références pour suivre combien de shared_ptr pointent vers la ressource.
- L'objet est supprimé lorsque le dernier shared_ptr qui le référence est détruit.
- Peut être copié et déplacé.
- A des coûts supplémentaires pour le compteur de références (généralement alloué séparément).
- Peut former des références cycliques, ce qui entraîne des fuites de mémoire.
```
#include <memory>

// Création de shared_ptr
std::shared_ptr<int> sp1 = std::make_shared<int>(20);

// Copie de propriété
std::shared_ptr<int> sp2 = sp1; // Le compteur de références augmente

// sp1 et sp2 possèdent l'objet
```
std::weak_ptr:
- Ne possède pas l'objet.
- Représente une "référence faible" à l'objet, gérée par un ou plusieurs shared_ptr.
- Utilisé pour prévenir les références cycliques entre shared_ptr.
- N'augmente pas le compteur de références de l'objet.
- Pour accéder en toute sécurité à l'objet, il faut le convertir en shared_ptr avec la méthode lock(). Si l'objet a déjà été supprimé, lock() renverra un shared_ptr vide.
```
#include <memory>

// Création de shared_ptr
std::shared_ptr<int> sp = std::make_shared<int>(30);

// Création de weak_ptr à partir de shared_ptr
std::weak_ptr<int> wp = sp;

// Vérification et utilisation de l'objet
if (auto shared_from_weak = wp.lock()) {
    // Accès à l'objet via shared_from_weak
} else {
    // L'objet a déjà été supprimé
}
```