Classe weak_ptr

Articolo
06/09/2015

Esegue il wrapping di un puntatore collegato in modo debole.

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

Parametri

Ty
Il tipo esaminato il puntatore debole.

Note

La classe modello descrive un oggetto che indica una risorsa gestita da uno o più oggetti di Classe shared_ptr. weak_ptr oggetti che puntano a una risorsa non influisce sul conteggio dei riferimenti di risorsa. Pertanto, quando l'ultimo oggetto di shared_ptr che gestisce tale risorsa viene eliminata la risorsa viene liberata, anche se vi sono oggetti di weak_ptr che fanno riferimento alla risorsa. Ciò è essenziale per evitare di cicli in strutture dei dati.

Punti di oggetto di weak_ptr a una risorsa se è stata creata da un oggetto di shared_ptr che possiede tale risorsa, se è stata creata da un oggetto di weak_ptr che indica la risorsa, oppure se la risorsa è stata distribuita con weak_ptr::operator=. Un oggetto di weak_ptr non fornisce l'accesso diretto alla risorsa cui punta. Il codice che deve utilizzare la risorsa esegue questa operazione tramite un oggetto di shared_ptr che possiede tale risorsa, creato chiamando la funzione membro weak_ptr::lock. Un oggetto di weak_ptr è scaduto quando la risorsa che punta è stata liberata in quanto tutti gli oggetti che shared_ptr possieda la risorsa è stata eliminata. Chiamando lock su un oggetto di weak_ptr scaduto crea un oggetto vuoto shared_ptr.

Un oggetto vuoto del weak_ptr non indica alcuna risorsa e non ha blocco di controllo. La funzione membro lock restituisce un oggetto vuoto shared_ptr.

Un ciclo si verifica quando due o più risorse controllate dagli oggetti di shared_ptr utilizzano escludono fare riferimento agli oggetti di shared_ptr. Ad esempio, un elenco collegato circolare con tre elementi include un nodo N0di intestazione; tale nodo utilizza un oggetto che possiede il nodo successivo, N1di shared_ptr ; tale nodo utilizza un oggetto che possiede il nodo successivo, N2di shared_ptr ; tale nodo, a sua volta, utilizzare un oggetto proprietario del nodo head, N0di shared_ptr, chiude il ciclo. In questa situazione, nessuno dei conteggi dei riferimenti diventeranno mai zero e i nodi nel ciclo non vengono liberati. Per eliminare il ciclo, l'ultimo nodo N2 deve utilizzare un oggetto di weak_ptr che punta a N0 anziché un oggetto di shared_ptr. Poiché l'oggetto di weak_ptr non possiede N0 non influisce sul conteggio dei riferimenti di N0 e quando il riferimento all'ultimo programma al nodo head viene eliminato i nodi nell'elenco viene distruggeranno.

Membri

Costruttori

weak_ptr::weak_ptr

Costruisce un oggetto weak_ptr.

Metodi

weak_ptr::element_type	Tipo dell'elemento.
weak_ptr::expired	Test se la proprietà è scaduto.
weak_ptr::lock	Ottiene la proprietà esclusivo a una risorsa.
weak_ptr::owner_before	Restituisce true se questo weak_ptr viene ordinato prima (o minore di) del puntatore fornito.
weak_ptr::reset	Risorsa personalizzata delle versioni.
weak_ptr::swap	Scambia due oggetti weak_ptr.
weak_ptr::use_count	Viene calcolato il numero di oggetti definiti di shared_ptr.

Operatori

weak_ptr::operator=

Risorsa personalizzata Replaces.

Requisiti

Header: <memory>

Spazio dei nomi: std

Vedere anche

Riferimenti

Classe shared_ptr

Altre risorse

<memoria> membri

Condividi tramite