¿Qué puntero se usa junto con shared_ptr?

weak_ptr.

#include <memory>
#include <iostream>

int main() {
    auto shared = std::make_shared<int>(10); // Crear shared_ptr
    std::weak_ptr<int> weak = shared;      // Crear weak_ptr desde shared_ptr

    if (auto locked = weak.lock()) {       // Intentar obtener shared_ptr desde weak_ptr
        std::cout << "Valor: " << *locked << std::endl;
    } else {
        std::cout << "Objeto eliminado." << std::endl;
    }

    shared.reset(); // El objeto apuntado por shared_ptr se elimina

    if (auto locked = weak.lock()) {       // Segundo intento, el objeto ya fue eliminado
        std::cout << "Valor: " << *locked << std::endl;
    } else {
        std::cout << "Objeto eliminado." << std::endl;
    }

    return 0;
}

weak_ptr junto con shared_ptr se usa para resolver problemas de referencias cíclicas y prevenir "memory hang" cuando dos o más objetos gestionados por shared_ptr se refieren entre sí, y los contadores de referencias nunca alcanzan cero.

Aquí están las propiedades principales de weak_ptr:

• No incrementa el contador de referencias: weak_ptr mantiene una referencia "débil" al objeto gestionado por shared_ptr, sin incrementar su contador de referencias fuertes.
• Verificación de la vida del objeto: Con el método lock() se puede intentar obtener un shared_ptr desde weak_ptr. Si el objeto aún está vivo, lock() devolverá un shared_ptr válido; de lo contrario, devolverá un shared_ptr vacío.
• No acceso directo: weak_ptr no proporciona acceso directo al contenido del objeto mediante los operadores * o ->. El acceso solo es posible después de una llamada exitosa a lock().

El uso de weak_ptr es una forma estándar de romper ciclos de referencias en estructuras de datos que usan shared_ptr, como grafos o listas doblemente enlazadas.