weak_ptr, classe

Article
06/09/2015

Encapsule un pointeur faiblement lié.

template<class Ty> class weak_ptr {
public:
    typedef Ty element_type;

    weak_ptr();
    weak_ptr(const weak_ptr&);
    template<class Other>
        weak_ptr(const weak_ptr<Other>&);
    template<class Other>
        weak_ptr(const shared_ptr<Other>&);

    weak_ptr& operator=(const weak_ptr&);
    template<class Other>
        weak_ptr& operator=(const weak_ptr<Other>&);
    template<class Other>
        weak_ptr& operator=(shared_ptr<Other>&);

    void swap(weak_ptr&);
    void reset();

    long use_count() const;
    bool expired() const;
    shared_ptr<Ty> lock() const;
    };

Paramètres

Ty
Le type contrôlé par le pointeur faible.

Notes

La classe du modèle décrit un objet qui pointe sur une ressource gérée par un ou plusieurs objets de shared_ptr, classe. Les objets weak_ptr qui pointent vers une ressource n'affectent pas le nombre de références de la ressource. Ainsi, lorsque le dernier objet shared_ptr qui gère la ressource est détruit la ressource sera libérée, même s'il existe des objets weak_ptr pointant vers cette ressource. Ceci est essentiel pour éviter des cycles dans les structures de données.

Un objet weak_ptr pointe vers une ressource s'il a été construit à partir d'un objet shared_ptr propriétaire de cette ressource, si elle a été construite à partir d'un objet weak_ptr qui pointe vers cette ressource, ou si cette ressource lui est affectée avec weak_ptr::operator=. Un objet weak_ptr ne fournit pas d'accès direct à la ressource vers laquelle il pointe. Le code qui doit utiliser la ressource le fait via un objet shared_ptr propriétaire de cette ressource, créé en appelant la méthode weak_ptr::lock. Un objet weak_ptr a expiré lorsque la ressource vers laquelle il pointe a été libérée car tous les objets shared_ptr propriétaires de la ressource ont été détruits. Appeler lock sur un objet weak_ptr qui a expiré crée un objet vide shared_ptr.

Un objet vide weak_ptr ne pointe vers aucune ressource et n'a pas de données de gestion. La méthode lock retourne un objet vide shared_ptr.

Un cycle se produit lorsque deux ressources ou plus contrôlées par des objets shared_ptr essayent mutuellement de référencer des objets shared_ptr. Par exemple, une liste circulaire liée avec trois éléments possède un nœud de tête N0 ; ce nœud contient un objet shared_ptr qui possède le nœud suivant, N1; ce nœud contient un objet shared_ptr qui possède le nœud suivant, N2; ce nœud, à son tour, contient un objet shared_ptr qui possède le nœud principal, N0, fermant le cycle. Dans ce cas, aucun des nombres de références ne devient jamais zéro, et les nœuds et du cycle ne sont pas libérés. Pour éliminer le cycle, le dernier nœud N2 doit contenir un objet weak_ptr pointant vers N0 au lieu d'un objet shared_ptr. Comme l'objet weak_ptr ne possède pas N0 cela n'affecte pas le nombre de références N0, et une fois que la dernière référence du programme au nœud principal est détruite les nœuds dans la liste sont également détruits.

Membres

Constructeurs

weak_ptr::weak_ptr

Construit un weak_ptr.

Méthodes

weak_ptr::element_type	Type de l'élément.
weak_ptr::expired	Vérifie si la propriété a expiré.
weak_ptr::lock	Obtient la propriété exclusive d'une ressource.
weak_ptr::owner_before	Renvoie true si ce weak_ptr est classé avant (ou inférieur à) le pointeur fourni.
weak_ptr::reset	Libère la ressource possédée.
weak_ptr::swap	Échanges deux objets weak_ptr.
weak_ptr::use_count	Compte le nombre d'objets shared_ptr désignés.

Opérateurs

weak_ptr::operator=

Remplace la ressource possédée.

Configuration requise

En-tête: <mémoire>

Espace de noms : std

Voir aussi

Référence

shared_ptr, classe

Autres ressources

<memory> membres

Partager via