shared_ptr y weak_ptr: propiedad compartida
Comparta la propiedad mediante el recuento de referencias y rompa ciclos con weak_ptr.
shared_ptr y weak_ptr: propiedad compartida es una lección gratuita de C++ Academy en CoddyKit. Esta es la lección 3 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de C++ Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de C++ Academy incluye 4 lecciones en total.
Compartir un objeto
A veces, varias partes del programa necesitan mantener vivo un objeto. std::shared_ptr<T> gestiona la propiedad compartida mediante un conteo de referencias.
Crear un shared_ptr
Use std::make_shared: reserva el bloque de control y el objeto en una sola asignación.
#include <memory>
auto s = std::make_shared<Widget>(42);
std::cout << s.use_count(); // 1Copiar comparte la propiedad
Copiar un shared_ptr incrementa el contador de referencias. Destruirlo o asignarle otro valor lo decrementa. Cuando el contador llega a 0, se elimina el objeto.
auto a = std::make_shared<Widget>();
auto b = a; // ref count is now 2
std::cout << a.use_count(); // 2Cómo funciona internamente
Un shared_ptr contiene dos punteros: uno al objeto y otro a un bloque de control que contiene los contadores de referencias. El bloque de control se reserva en el heap.
Contador atómico de referencias
El contador de referencias utiliza operaciones atómicas para que los shared_ptr se puedan copiar entre hilos de forma segura. Sin embargo, el objeto apuntado no es automáticamente seguro para hilos.
Restablecer y reasignar
Asignar un valor nuevo decrementa el contador de referencias antiguo e incrementa el nuevo. reset() deja el shared_ptr vacío.
shared_ptr a partir de un puntero sin formato (evítelo)
No construya dos shared_ptr a partir del mismo puntero sin formato, ya que cada uno tendría su propio bloque de control. Use siempre make_shared.
// BUG
Widget* raw = new Widget();
std::shared_ptr<Widget> a(raw);
std::shared_ptr<Widget> b(raw); // disaster: two control blocksEl problema de los ciclos
Dos shared_ptr que se referencian mutuamente forman un ciclo: el contador de referencias de ninguno llega a cero y ninguno se libera. Se produce una fuga de memoria.
struct Node {
std::shared_ptr<Node> next;
};
auto a = std::make_shared<Node>();
auto b = std::make_shared<Node>();
a->next = b;
b->next = a; // cycle — never freedRomper ciclos con weak_ptr
std::weak_ptr<T> observa un shared_ptr sin participar en el contador de referencias. Use weak en uno de los lados de la relación para romper el ciclo.
struct Node {
std::shared_ptr<Node> next;
std::weak_ptr<Node> prev; // weak — does not own
};Uso de weak_ptr
No puede desreferenciar directamente un weak_ptr. Llame a lock() para obtener un shared_ptr, o uno vacío si el objeto ya se destruyó.
std::weak_ptr<Widget> w = sharedPtr;
if (auto p = w.lock()) {
p->use(); // safe — we have a shared_ptr now
} else {
std::cout << "object expired";
}Coste frente a unique_ptr
shared_ptr ocupa más espacio (dos punteros y un bloque de control) y es más lento (por el contador de referencias atómico). Úselo solo cuando sea realmente necesario compartir la propiedad.
Comprobación rápida
¿Cuál es el caso de uso habitual de std::weak_ptr?
Resumen
shared_ptr realiza el seguimiento de la propiedad mediante un contador de referencias atómico. Use make_shared, tenga cuidado con los ciclos y rómpalos con weak_ptr. Prefiera unique_ptr cuando no sea necesario compartir la propiedad.
Preguntas frecuentes
¿La lección «shared_ptr y weak_ptr: propiedad compartida» es gratis?
Sí — el texto completo de «shared_ptr y weak_ptr: propiedad compartida» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de C++ Academy, actualiza a CoddyKit PRO. El curso de C++ Academy incluye 4 lecciones en total.
¿Qué aprenderé en «shared_ptr y weak_ptr: propiedad compartida»?
Comparta la propiedad mediante el recuento de referencias y rompa ciclos con weak_ptr. Practicas C++ Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar C++ Academy?
No se requiere experiencia previa. C++ Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 3 de 4.
¿Cuánto tiempo toma la lección «shared_ptr y weak_ptr: propiedad compartida»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de C++ Academy?
Sí. Cada lección de C++ Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- Por qué los punteros inteligentes sustituyen a new y delete sin formato
- unique_ptr y propiedad exclusiva
- shared_ptr y weak_ptr: propiedad compartida
- Eliminadores personalizados y funciones make