Classe weak_ptr

Artigo
06/09/2015

Envolve um ponteiro fraco associado.

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

Parâmetros

Ty
O tipo controlado pelo ponteiro fraco.

Comentários

A classe do modelo descreve um objeto que aponta para um recurso que é gerenciada por um ou mais objetos de Classe shared_ptr . weak_ptr objetos desse ponto em um recurso não afeta a contagem de referência de recurso. Portanto, quando o objeto mais recente de shared_ptr que gerencia esse recurso é destruído o recurso será liberado, mesmo se houver objetos de weak_ptr que apontam para esse recurso. Isso é essencial para impedir ciclos em estruturas de dados.

Pontos de objeto de weak_ptr a um recurso se foi construído de um objeto de shared_ptr que possui esse recurso, se foi construído de um objeto de weak_ptr que aponta para esse recurso, ou se esse recurso foi alocado a weak_ptr::operator=. Um objeto de weak_ptr não fornece acesso direto ao recurso apontados por. O código que precisa usar o recurso faz isso por meio de um objeto de shared_ptr que possui esse recurso, criado chamando a função de membro weak_ptr::lock. Um objeto de weak_ptr expirou enquanto o recurso que aponta foi liberado porque todo o shared_ptr objeto que é o proprietário do recurso foi destruído. A chamada lock em um objeto de weak_ptr que expirou cria um objeto vazio de shared_ptr.

Um objeto vazio de weak_ptr não aponta para nenhum recurso e não tem nenhum pacote de controle. A função de membro lock retorna um objeto vazio de shared_ptr.

Um ciclo ocorre quando duas ou mais recursos controlados por objetos de shared_ptr manter mutuamente objetos de referência de shared_ptr . Por exemplo, uma lista vinculada circular com três elementos têm um nó N0de início; esse nó contém um objeto que possui o nó seguir, N1de shared_ptr ; esse nó contém um objeto que possui o nó seguir, N2de shared_ptr ; esse nó, por sua vez, contém um objeto que possui o nó principal, N0de shared_ptr , fechando o ciclo. Nessa situação, nenhuma das contagens de referência nunca serão zero, e os nós no ciclo não serão liberados. Para eliminar o ciclo, o último nó N2 deve manter um objeto de weak_ptr que aponta para N0 em vez de um objeto de shared_ptr . Desde que o objeto de weak_ptr não possuir N0 não afeta a contagem de referência de N0 , e quando a última referência de programa ao nó principal é destruída os nós na lista também serão destruídos.

Membros

Construtores

weak_ptr::weak_ptr

Constrói um weak_ptr.

Métodos

weak_ptr::element_type	O tipo de elemento.
weak_ptr::expired	Testa se a propriedade expirou.
weak_ptr::lock	Obtém a propriedade exclusiva de um recurso.
weak_ptr::owner_before	Retorna true se esse weak_ptr é ordenado antes ou (menor que) do ponteiro fornecido.
weak_ptr::reset	Recursos de propriedade de versões.
weak_ptr::swap	Alterna dois objetos weak_ptr.
weak_ptr::use_count	Número das contagens de objetos designados de shared_ptr .

Operadores

weak_ptr::operator=

Recurso de propriedade Substitui.

Requisitos

Cabeçalho: <memória>

Namespace: std

Consulte também

Referência

Classe shared_ptr

Outros recursos

<memory> Membros

Partilhar via