weak_ptr Class

Encapsule un pointeur faiblement attaché.

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 de modèle décrit un objet qui indique une ressource qui est gérée par un ou plusieurs objets de shared_ptr Class .Les objets d' weak_ptr qui indiquent une ressource n'affectent pas le nombre de références de ressources.Par conséquent, lorsque le dernier objet d' shared_ptr qui gère cette ressource est perdu la ressource est libérée, même s'il existe des objets d' weak_ptr pointant sur cette ressource.Il est essentiel pour éviter des cycles dans des structures de données.

Points d'objet d' weak_ptr à une ressource si elle a été développée d'un objet d' shared_ptr qui possède cette ressource, si elle a été développée d'un objet d' weak_ptr qui indique cette ressource, ou si cette ressource lui a été assignée à weak_ptr::operator=.Un objet d' weak_ptr ne fournit pas l'accès direct à la ressource laquelle il pointe.Le code qui doit utiliser la ressource fait via un objet d' shared_ptr qui possède cette ressource, créé en appelant la fonction membre weak_ptr::lock.Un objet d' weak_ptr a expiré lorsque la ressource laquelle il indique a été libéré parce que tous les objets d' shared_ptr que posséder la ressource détruits.Appelant lock sur un objet d' weak_ptr qui a expiré crée un objet vide de shared_ptr.

Un objet vide de weak_ptr n'indique aucune ressource et n'a aucun bloc de contrôle.Sa fonction membre lock retourne un objet vide de shared_ptr.

Un cycle se produit lorsque deux ou plusieurs ressources contrôlées par les objets d' shared_ptr jugez mutuellement référencer des objets d' shared_ptr .Par exemple, une liste liée circulaire avec trois éléments a un nœud N0de tête ; ce nœud contient un objet d' shared_ptr qui possède le premier nœud, N1; ce nœud contient un objet d' shared_ptr qui possède le premier nœud, N2; ce nœud, à son tour, contient un objet d' shared_ptr qui possède le nœud principal, N0, ou le cycle.Dans ce cas, aucun des nombres de références ne devient jamais zéro, et les nœuds dans le cycle ne seront pas libérés.Pour supprimer le cycle, le dernier nœud N2 doit contenir un objet d' weak_ptr pointant sur N0 au lieu d'un objet d' shared_ptr .Étant donné que l'objet d' weak_ptr ne possède pas N0 il n'affecte pas le décompte de références d' N0, et lorsque la dernière référence du programme au nœud principal est perdue les nœuds dans la liste seront également détruits.

Membres

Constructeurs

Méthodes

Opérateurs

Configuration requise

En-tête : <memory>

L'espace de noms : DST

Voir aussi

Référence

shared_ptr Class

Autres ressources

<memory> membres