Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / C++

std::weak_ptr — observer sans prolonger la durée de vie de l’objet

std::weak_ptr<T> observe un objet géré par std::shared_ptr sans le maintenir en vie. Sa méthode lock() obtient temporairement un propriétaire partagé, ou un std::shared_ptr vide si la propriété a déjà expiré.

Version : C++23; repository compiler flag, production runtime not attested

Syntaxe

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

std::weak_ptr<T>, déclaré dans <memory>, stocke une référence faible associée à la propriété gérée par std::shared_ptr. Il n’augmente pas le nombre de propriétaires forts et ne prolonge pas la durée de vie de l’objet. Construisez-le à partir d’un std::shared_ptr compatible ou laissez-le vide.

Il ne fournit ni * ni ->. Appelez lock() et vérifiez le std::shared_ptr renvoyé. L’acquisition de la propriété partagée est atomique : la méthode renvoie un propriétaire partagé ou un pointeur vide si la propriété a expiré, sans lancer d’exception. Conservez le résultat pendant toute la durée d’accès à l’objet.

expired() signifie use_count() == 0 ; use_count() compte les propriétaires forts, pas les observateurs. Vérifier uniquement expired() ne garantit pas la durée de vie : un autre thread peut libérer le dernier propriétaire avant un appel ultérieur à lock(). Le caractère atomique de lock() ne synchronise pas l’accès aux données de l’objet.

Les références faibles sont utiles pour observer un objet et rompre les cycles de propriété : une référence de retour peut utiliser std::weak_ptr plutôt qu’un autre propriétaire fort. reset() vide l’observateur sans détruire l’objet observé. L’exemple utilise des fonctionnalités disponibles en C++23 ; le projet de norme actuel fourni contient également des extensions ultérieures.

Exemples

#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';
}

Résultat

42
true
false

Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.

Sources