CKTIS / C++
std::shared_ptr — propiedad compartida
std::shared_ptr<T> de <memory> permite compartir la propiedad de un objeto. Las copias lo mantienen vivo y la liberación del último propietario activa la limpieza. std::weak_ptr observa el objeto sin prolongar su vida útil.
Versión: C++23; repository compiler flag, production runtime not attested
Sintaxis
#include <memory>
std::shared_ptr<T> p = std::make_shared<T>(args...);
std::shared_ptr<T> q = p;
p.reset();std::shared_ptr<T> de <memory> representa propiedad compartida. Al copiarlo, se comparte la propiedad del objeto en lugar de copiarlo. reset() libera la parte de un propietario; el último propietario activa la eliminación del objeto administrado o la llamada al deleter correspondiente. get() solo expone el puntero almacenado: no transfiere la propiedad.
Crea un objeto con std::make_shared<T>(args...), que reenvía los argumentos a su constructor. No construyas un std::shared_ptr independiente a partir de p.get(): esto crea un grupo de propietarios separado y puede causar una doble eliminación. Antes de desreferenciarlo, asegúrate de que el puntero almacenado apunta a un objeto vivo.
Los ciclos de referencias fuertes pueden mantener los objetos vivos indefinidamente. Rompe un ciclo con std::weak_ptr, que no prolonga la vida útil del objeto. lock() devuelve un std::shared_ptr que comparte la propiedad si queda al menos un propietario en el grupo observado. Si el grupo ha expirado, lock() devuelve un std::shared_ptr vacío aunque el objeto siga vivo, por ejemplo, porque el deleter no hace nada.
La gestión segura de la propiedad no sincroniza los datos del objeto. Se pueden usar simultáneamente instancias distintas que compartan la propiedad; modificar la misma instancia requiere sincronización, por ejemplo, con std::atomic<std::shared_ptr<T>>. El acceso al objeto en sí necesita protección aparte si puede haber una carrera de datos. use_count() no es un mecanismo de sincronización.
El ejemplo muestra que q mantiene vivo el objeto después de p.reset() y que el observador expira cuando termina el bloque. Esta entrada se refiere a C++23; el borrador de trabajo proporcionado se actualiza y puede incluir características posteriores. Una opción del compilador en el repositorio no certifica el entorno de ejecución de producción.
Ejemplos
#include <iostream>
#include <memory>
int main() {
auto p = std::make_shared<int>(42);
std::weak_ptr<int> observer = p;
{
std::shared_ptr<int> q = p;
p.reset();
std::cout << *q << '\n';
std::cout << std::boolalpha << observer.expired() << '\n';
}
std::cout << observer.expired() << '\n';
}
Resultado
42 false true
El código mostrado y el resultado declarado se verificaron en un entorno aislado mediante el método registrado en la evidencia de verificación de esta versión exacta.