Lecciones del módulo (1/2)
std::unique_ptr y std::shared_ptr
En C++ clásico, la gestión manual de la memoria a través de los operadores new y delete es una fuente común de errores graves, como fugas de memoria (recursos nunca liberados) o dangling pointers (punteros que apuntan a memoria ya liberada).
El C++ moderno introduce los Punteros Inteligentes (Smart Pointers), definidos en la cabecera <memory>. Estos gestionan automáticamente el ciclo de vida de la memoria asignada en el heap mediante la técnica RAII (Resource Acquisition Is Initialization), liberando el recurso cuando el puntero sale del ámbito (scope).
std::unique_ptr
std::unique_ptr expresa el concepto de propiedad exclusiva de un recurso. No se puede copiar, sino que solo se puede mover (mediante 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 el concepto de propiedad compartida. Varios punteros pueden apuntar al mismo recurso. La clase mantiene internamente un contador de referencias (reference count): la memoria se libera únicamente cuando el último shared_ptr activo se destruye o se libera.
#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)
Pruébalo tú mismo
Declara un std::unique_ptr<int> llamado ptr inicializándolo con std::make_unique con valor 42. Imprime el valor dereferenciado de ptr usando std::cout.
Mostrar pista
Usa `std::unique_ptr<int> ptr = std::make_unique<int>(42);` y luego envía `*ptr` al flujo de salida.
Solución disponible después de 3 intentos
Instancia un std::shared_ptr<int> llamado ptr1 con valor 100 usando std::make_shared. Crea una copia llamada ptr2 y finalmente imprime el valor devuelto por ptr1.use_count() a través de std::cout.
Mostrar pista
La copia se realiza con una asignación normal `ptr2 = ptr1;`. Al imprimir `ptr1.use_count()` deberías visualizar 2.
Solución disponible después de 3 intentos