Quali sono i puntatori intelligenti in C++?

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

std::unique_ptr:
- Proprietà esclusiva dell'oggetto.
- Non può essere copiato, ma può essere spostato (std::move).
- Rimuove automaticamente l'oggetto all'uscita dal scope o alla distruzione di unique_ptr.
- È leggero, senza costi aggiuntivi per il contatore di riferimenti.
```
#include <memory>

// Creazione di unique_ptr
std::unique_ptr<int> up1(new int(10));

// Spostamento di proprietà
std::unique_ptr<int> up2 = std::move(up1);

// up1 ora è nullptr
// up2 possiede l'oggetto
```
std::shared_ptr:
- Proprietà condivisa dell'oggetto.
- Usa un contatore di riferimenti per tracciare quanti shared_ptr puntano alla risorsa.
- L'oggetto viene eliminato quando l'ultimo shared_ptr che lo punta viene distrutto.
- Può essere copiato e spostato.
- Ha costi aggiuntivi per il contatore di riferimenti (solitamente allocato separatamente).
- Può formare riferimenti ciclici, portando a perdite di memoria.
```
#include <memory>

// Creazione di shared_ptr
std::shared_ptr<int> sp1 = std::make_shared<int>(20);

// Copia di proprietà
std::shared_ptr<int> sp2 = sp1; // Il contatore di riferimenti aumenta

// sp1 e sp2 possiedono l'oggetto
```
std::weak_ptr:
- Non possiede l'oggetto.
- Rappresenta un "riferimento debole" all'oggetto, gestito da uno o più shared_ptr.
- Viene usato per prevenire riferimenti ciclici tra shared_ptr.
- Non aumenta il contatore di riferimenti dell'oggetto.
- Per accedere in modo sicuro all'oggetto, bisogna convertirlo in shared_ptr usando il metodo lock(). Se l'oggetto è già stato eliminato, lock() restituirà un shared_ptr vuoto.
```
#include <memory>

// Creazione di shared_ptr
std::shared_ptr<int> sp = std::make_shared<int>(30);

// Creazione di weak_ptr da shared_ptr
std::weak_ptr<int> wp = sp;

// Verifica e utilizzo dell'oggetto
if (auto shared_from_weak = wp.lock()) {
    // Accesso all'oggetto tramite shared_from_weak
} else {
    // L'oggetto è già stato eliminato
}
```