Lezioni del modulo (1/2)
std::unique_ptr e std::shared_ptr
Nel C++ classico, la gestione manuale della memoria tramite gli operatori new e delete è una fonte comune di errori gravi, come leak di memoria (risorse mai rilasciate) o dangling pointers (puntatori che puntano a memoria già deallocata).
Il C++ moderno introduce i Puntatori Intelligenti (Smart Pointers), definiti nell'header <memory>. Essi gestiscono automaticamente il ciclo di vita della memoria allocata nell'heap tramite la tecnica RAII (Resource Acquisition Is Initialization), deallocando la risorsa quando il puntatore va fuori scope.
std::unique_ptr
std::unique_ptr esprime il concetto di proprietà esclusiva di una risorsa. Non può essere copiato, ma solo spostato (tramite std::move).
#include <memory>
// Creazione consigliata tramite std::make_unique (C++14)
std::unique_ptr<int> p1 = std::make_unique<int>(42);
// Accesso alla risorsa come un normale puntatore
std::cout << *p1 << std::endl;
// std::unique_ptr<int> p2 = p1; // ERRORE DI COMPILAZIONE: copia non ammessa!
std::unique_ptr<int> p2 = std::move(p1); // Consentito: p1 cede la proprietà a p2
std::shared_ptr
std::shared_ptr implementa il concetto di proprietà condivisa. Più puntatori possono puntare alla stessa risorsa. La classe mantiene internamente un contatore dei riferimenti (reference count): la memoria viene liberata solo quando l'ultimo shared_ptr attivo viene distrutto o rilasciato.
#include <memory>
std::shared_ptr<int> s1 = std::make_shared<int>(100);
std::shared_ptr<int> s2 = s1; // Consentito: incremento del reference count
std::cout << s1.use_count() << std::endl; // Stampa 2 (s1 e s2 condividono la risorsa)
Prova tu
Dichiara un std::unique_ptr<int> chiamato ptr inizializzandolo con std::make_unique con valore 42. Stampa il valore dereferenziato di ptr usando std::cout.
Mostra suggerimento
Usa `std::unique_ptr<int> ptr = std::make_unique<int>(42);` e poi invia `*ptr` allo stream di output.
Soluzione disponibile dopo 3 tentativi
Instanzia un std::shared_ptr<int> chiamato ptr1 con valore 100 usando std::make_shared. Crea una copia chiamata ptr2 ed infine stampa il valore ritornato da ptr1.use_count() tramite std::cout.
Mostra suggerimento
La copia si effettua con una normale assegnazione `ptr2 = ptr1;`. Stampando `ptr1.use_count()` dovresti visualizzare 2.
Soluzione disponibile dopo 3 tentativi