weak_ptr Class

Esegue il wrapping di un puntatore debole collegato.

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 punta a una risorsa che viene gestita da uno o più oggetti di shared_ptr Class.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 verrà liberata, anche se vi sono oggetti di weak_ptr che punta 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 proprietario della 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 a cui punta.Il codice che deve utilizzare la risorsa viene eseguita questa operazione tramite un oggetto di shared_ptr proprietario della risorsa, creato chiamando la funzione membro weak_ptr::lock.Un oggetto di weak_ptr è scaduto quando la risorsa che punta è stata liberata poiché tutto shared_ptr oggetti che possieda la risorsa è stata eliminata.Chiamando lock su un oggetto di weak_ptr scaduto crea un oggetto vuoto di 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 di 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, il nodo viene utilizzato un oggetto che possiede il nodo seguente, N1di shared_ptr ; il nodo viene utilizzato un oggetto che possiede il nodo seguente, N2di shared_ptr ; tale nodo, a sua volta, utilizza un oggetto che possiede il nodo head, N0di shared_ptr, chiude il ciclo.In questa situazione, nessuno dei conteggi dei riferimenti mai aumentano in base 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 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 di weak_ptr.
weak_ptr::use_count	Calcola il numero di oggetti definiti di shared_ptr.

Operatori

weak_ptr::operator=

Risorsa personalizzata Replaces.

Requisiti

Intestazione: <memory>

Spazio dei nomi: deviazione standard

Vedere anche

Riferimenti

shared_ptr Class

Altre risorse

<memoria> membri