Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / C++

std::weak_ptr — observar sin prolongar la vida del objeto

std::weak_ptr<T> observa un objeto administrado por std::shared_ptr sin mantenerlo vivo. Su método lock() obtiene temporalmente un propietario compartido o un std::shared_ptr vacío si la propiedad ya ha expirado.

Versión: C++23; repository compiler flag, production runtime not attested

Sintaxis

#include <memory>
std::weak_ptr<T> observer = owner;
if (auto held = observer.lock()) {
    // Access the object through held.
}

std::weak_ptr<T>, declarado en <memory>, almacena una referencia débil asociada a la propiedad administrada por std::shared_ptr. No aumenta el número de propietarios fuertes ni prolonga la vida del objeto. Créalo a partir de un std::shared_ptr compatible o déjalo vacío.

No proporciona ni * ni ->. Llama a lock() y comprueba el std::shared_ptr devuelto. La adquisición de propiedad compartida es atómica: el método devuelve un propietario compartido o un puntero vacío si la propiedad ha expirado, sin lanzar excepciones. Mantén el resultado mientras accedes al objeto.

expired() significa use_count() == 0; use_count() cuenta los propietarios fuertes, no los observadores. Comprobar solo expired() no garantiza que el objeto siga vivo: otro hilo puede liberar al último propietario antes de una llamada posterior a lock(). La atomicidad de lock() no sincroniza el acceso a los datos del objeto.

Las referencias débiles son útiles para observar y romper ciclos de propiedad: una referencia de retorno puede usar std::weak_ptr en lugar de otro propietario fuerte. reset() vacía el observador sin destruir el objeto observado. El ejemplo usa funciones disponibles en C++23; el borrador actual de la norma proporcionado también contiene extensiones posteriores.

Ejemplos

#include <iostream>
#include <memory>

int main() {
    std::weak_ptr<int> observer;
    {
        auto owner = std::make_shared<int>(42);
        observer = owner;
        if (auto held = observer.lock()) {
            std::cout << *held << '\n';
        }
    }
    std::cout << std::boolalpha << observer.expired() << '\n';
    std::cout << static_cast<bool>(observer.lock()) << '\n';
}

Resultado

42
true
false

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.

Fuentes