Contenido del Curso
C++ Smart Pointers
C++ Smart Pointers
Funciones Importantes de Punteros Weak
La función expired()
Antes de llamar a lock(), puedes verificar si un puntero débil sigue siendo válido usando el método expired(). Esta función devuelve true si el objeto ha sido destruido y false en caso contrario.
expired_function
// Call `expired()` before `lock()` if (!p_weak.expired()) { // Lock only if the object is still alive auto p_shared = p_weak.lock(); p_shared->update(); } else { std::cout << "Object no longer exists" << std::endl; }
Llamar a expired() antes de bloquear el puntero débil ayuda a determinar si el objeto referenciado aún existe.
La función use_count()
Aunque un puntero débil no afecta el conteo de referencias de un objeto, puede ser útil saber cuántas instancias de std::shared_ptr están gestionando el mismo objeto. La función use_count() devuelve este número.
use_count_function
std::shared_ptr<int> p_shared = std::make_shared<int>(42); std::weak_ptr<int> p_weak(sharedPtr); // Should output one std::cout << p_weak.use_count() << std::endl;
La función reset()
Para liberar un puntero débil de observar un objeto, utiliza la función reset(). Esto hace que el puntero débil quede vacío, lo que significa que ya no apunta a ningún objeto.
reset_function
std::weak_ptr<int> p_weak(sharedPtr); // After this, `p_weak` no longer observes the `p_shared` object p_weak.reset();
La función swap()
La función swap() se puede usar para intercambiar el contenido de dos punteros débiles. Esto es particularmente útil cuando deseas cambiar los objetos que los dos punteros débiles están observando, sin alterar la propiedad o la duración de los objetos dinámicos.
swap_function
std::shared_ptr<int> p_shared_A = std::make_shared<int>(10); std::shared_ptr<int> p_shared_B = std::make_shared<int>(20); std::weak_ptr<int> p_weak_A(p_shared_A); std::weak_ptr<int> p_weak_B(p_shared_B); // Swaps the objects `p_weak_A` and `p_weak_B` p_weak_A.swap(weakPtrB);
inicialmente p_weak_A observa el objeto gestionado por p_shared_A, mientras que p_weak_B observa el objeto gestionado por p_shared_B.
Después de llamar a swap(), p_weak_A comienza a observar el objeto gestionado por p_shared_B, y p_weak_B observa el objeto gestionado por p_shared_A.
¡Gracias por tus comentarios!
