Classe weak_ptr

Encapsula um ponteiro vinculado de modo fraco.

Sintaxe

template<class T> class weak_ptr;

Parâmetros

T
O tipo controlado pelo ponteiro fraco.

Comentários

O modelo de classe descreve um objeto que aponta para um recurso que é gerenciado por um ou mais objetos shared_ptr. Os objetos weak_ptr que apontam para um recurso não afetam a contagem de referência do recurso. Quando o último objeto shared_ptr que gerencia esse recurso for destruído, o recurso será liberado, mesmo se houver objetos weak_ptr apontando para esse recurso. Esse comportamento é essencial para evitar ciclos em estruturas de dados.

O objeto weak_ptr aponta para um recurso se ele foi construído a partir de um objeto shared_ptr que possui esse recurso, se ele foi construído a partir de um objeto weak_ptr que aponta para esse recurso ou se esse recurso foi atribuído com operator=. Um objeto weak_ptr não fornece acesso direto ao recurso para o qual ele aponta. O código que precisa usar o recurso faz isso por meio de um objeto shared_ptr que possui esse recurso, criado chamando a função membro lock. Um objeto weak_ptr expirou quando o recurso para o qual ele aponta foi liberado porque todos os objetos shared_ptr que têm o recurso foram destruídos. Chamar lock em um objeto weak_ptr que expirou cria um objeto shared_ptr vazio.

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

Um ciclo ocorre quando dois ou mais recursos controlados por objetos shared_ptr contêm mutuamente objetos shared_ptr de referência. Por exemplo, uma lista vinculada circular com três elementos tem um nó principal N0; esse nó contém um objeto shared_ptr que tem o próximo nó, N1; esse nó contém um objeto shared_ptr que tem o próximo nó, N2; esse nó, por sua vez, contém um objeto shared_ptr que tem o nó principal, N0, fechando o ciclo. Nessa situação, as contagens de referência nunca se tornarão zero e os nós no ciclo nunca serão liberados. Para eliminar o ciclo, o último nó N2 deve conter um objeto weak_ptr apontando para N0 em vez de um objeto shared_ptr. Como o objeto weak_ptr não possui N0, ele não afetará a contagem de referência de N0 e quando a última referência do programa ao nó principal for destruída, os nós na lista também serão destruídos.

Membros

element_type

O tipo do elemento.

typedef T element_type; // through C++17
using element_type = remove_extent_t<T>; // C++20

Comentários

O tipo é um sinônimo do parâmetro de modeloT.

Exemplo

// std__memory__weak_ptr_element_type.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>

int main()
{
    std::shared_ptr<int> sp0(new int(5));
    std::weak_ptr<int> wp0(sp0);
    std::weak_ptr<int>::element_type val = *wp0.lock();

    std::cout << "*wp0.lock() == " << val << std::endl;

    return (0);
}

*wp0.lock() == 5

expired

Testa se a propriedade expirou, ou seja, o objeto referenciado foi excluído.

bool expired() const noexcept;

Comentários

A função membro retornará true se *this expirar, caso contrário, false.

Exemplo

// std__memory__weak_ptr_expired.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>

int main()
{
    std::weak_ptr<int> wp;

    {
        std::shared_ptr<int> sp(new int(10));
        wp = sp;
        std::cout << "wp.expired() == " << std::boolalpha
            << wp.expired() << std::endl;
        std::cout << "*wp.lock() == " << *wp.lock() << std::endl;
    }

    // check expired after sp is destroyed
    std::cout << "wp.expired() == " << std::boolalpha
        << wp.expired() << std::endl;
    std::cout << "(bool)wp.lock() == " << std::boolalpha
        << (bool)wp.lock() << std::endl;

    return (0);
}

wp.expired() == false
*wp.lock() == 10
wp.expired() == true
(bool)wp.lock() == false

lock

Obtém um shared_ptr que compartilha a propriedade de um recurso.

shared_ptr<T> lock() const noexcept;

Comentários

A função membro retornará um objeto shared_ptr vazio se *this tive expirado; caso contrário, retornará um objeto shared_ptr<T> que possui o recurso para o qual *this aponta. Retorna um valor equivalente à execução atômica de expired() ? shared_ptr<T>() : shared_ptr<T>(*this).

Exemplo

// std__memory__weak_ptr_lock.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>

int main()
{
    std::weak_ptr<int> wp;

    {
        std::shared_ptr<int> sp(new int(10));
        wp = sp;
        std::cout << "wp.expired() == " << std::boolalpha
            << wp.expired() << std::endl;
        std::cout << "*wp.lock() == " << *wp.lock() << std::endl;
    }

    // check expired after sp is destroyed
    std::cout << "wp.expired() == " << std::boolalpha
        << wp.expired() << std::endl;
    std::cout << "(bool)wp.lock() == " << std::boolalpha
        << (bool)wp.lock() << std::endl;

    return (0);
}

wp.expired() == false
*wp.lock() == 10
wp.expired() == true
(bool)wp.lock() == false

operator=

Substitui o recurso possuído.

weak_ptr& operator=(const weak_ptr& ptr) noexcept;

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

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

Parâmetros

Other
O tipo controlado pelo ponteiro fraco ou compartilhado do argumento.

ptr
O ponteiro fraco ou o ponteiro compartilhado a ser copiado.

Comentários

Todos os operadores liberam o recurso apontado no momento por *this e atribuem a propriedade do recurso nomeada por ptr até *this. Se um operador falhar, ele deixará *this inalterado. Cada operador tem um efeito equivalente a weak_ptr(ptr).swap(*this).

Exemplo

// std__memory__weak_ptr_operator_as.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>

int main()
{
    std::shared_ptr<int> sp0(new int(5));
    std::weak_ptr<int> wp0(sp0);
    std::cout << "*wp0.lock() == " << *wp0.lock() << std::endl;

    std::shared_ptr<int> sp1(new int(10));
    wp0 = sp1;
    std::cout << "*wp0.lock() == " << *wp0.lock() << std::endl;

    std::weak_ptr<int> wp1;
    wp1 = wp0;
    std::cout << "*wp1.lock() == " << *wp1.lock() << std::endl;

    return (0);
}

*wp0.lock() == 5
*wp0.lock() == 10
*wp1.lock() == 10

owner_before

Retorna true se esse weak_ptr é ordenado antes (ou menor que) o ponteiro fornecido.

template <class Other>
bool owner_before(const shared_ptr<Other>& ptr) const noexcept;

template <class Other>
bool owner_before(const weak_ptr<Other>& ptr) const noexcept;

Parâmetros

ptr
Uma referência de lvalue a um shared_ptr ou um weak_ptr.

Comentários

A função membro do modelo retornará true se *this for ordenado antes de ptr.

reset

Libera o recurso possuído.

void reset() noexcept;

Comentários

A função membro libera o recurso apontado por *this e converte *this em um objeto weak_ptr vazio.

Exemplo

// std__memory__weak_ptr_reset.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>

int main()
{
    std::shared_ptr<int> sp(new int(5));
    std::weak_ptr<int> wp(sp);
    std::cout << "*wp.lock() == " << *wp.lock() << std::endl;
    std::cout << "wp.expired() == " << std::boolalpha
        << wp.expired() << std::endl;

    wp.reset();
    std::cout << "wp.expired() == " << std::boolalpha
        << wp.expired() << std::endl;

    return (0);
}

*wp.lock() == 5
wp.expired() == false
wp.expired() == true

swap

Troca dois objetos weak_ptr.

void swap(weak_ptr& wp) noexcept;

Também inclui a especialização:

template<class T>
void swap(weak_ptr<T>& a, weak_ptr<T>& b) noexcept;

Parâmetros

wp
O ponteiro fraco pelo qual deve ser trocado.

Comentários

Após um swap, o recurso originalmente apontado por *this será apontado por wp, e o recurso originalmente apontado por wp será apontado por *this. A função não altera as contagens de referências dos dois recursos e ela não gera exceções. O efeito da especialização do modelo é equivalente a a.swap(b).

Exemplo

// std__memory__weak_ptr_swap.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>

int main()
{
    std::shared_ptr<int> sp1(new int(5));
    std::shared_ptr<int> sp2(new int(10));
    std::cout << "*sp1 == " << *sp1 << std::endl;

    sp1.swap(sp2);
    std::cout << "*sp1 == " << *sp1 << std::endl;

    swap(sp1, sp2);
    std::cout << "*sp1 == " << *sp1 << std::endl;
    std::cout << std::endl;

    std::weak_ptr<int> wp1(sp1);
    std::weak_ptr<int> wp2(sp2);
    std::cout << "*wp1 == " << *wp1.lock() << std::endl;

    wp1.swap(wp2);
    std::cout << "*wp1 == " << *wp1.lock() << std::endl;

    swap(wp1, wp2);
    std::cout << "*wp1 == " << *wp1.lock() << std::endl;

    return (0);
}

*sp1 == 5
*sp1 == 10
*sp1 == 5

*wp1 == 5
*wp1 == 10
*wp1 == 5

use_count

Conta o número de objetos shared_ptr que são proprietários do recurso compartilhado.

long use_count() const noexcept;

Comentários

A função membro retorna o número de objetos shared_ptr que tem do recurso apontado por *this.

Exemplo

// std__memory__weak_ptr_use_count.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>

int main()
{
    std::shared_ptr<int> sp1(new int(5));
    std::weak_ptr<int> wp(sp1);
    std::cout << "wp.use_count() == "
        << wp.use_count() << std::endl;

    std::shared_ptr<int> sp2(sp1);
    std::cout << "wp.use_count() == "
        << wp.use_count() << std::endl;

    return (0);
}

wp.use_count() == 1
wp.use_count() == 2

weak_ptr

Constrói um weak_ptr.

constexpr weak_ptr() noexcept;

weak_ptr(const weak_ptr& wp) noexcept;

weak_ptr(weak_ptr&& wp) noexcept;

template <class Other>
weak_ptr(const weak_ptr<Other>& wp) noexcept;

template <class Other>
weak_ptr(weak_ptr<Other>&& sp) noexcept;

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

Parâmetros

Other
O tipo controlado pelo ponteiro compartilhado/fraco do argumento. Esses construtores não participam da resolução de sobrecarga, a menos que Other* seja compatível com element_type*.

wp
O ponteiro fraco a ser copiado.

sp
O ponteiro compartilhado a ser copiado.

Comentários

O construtor padrão constrói um objeto weak_ptr vazio. Os construtores que assumem um argumento cada constroem um objeto weak_ptr vazio se o ponteiro do argumento estiver vazio. Caso contrário, eles constroem um objeto weak_ptr que aponta para o recurso nomeado pelo argumento. A contagem de referência do objeto compartilhado não é alterada.

Exemplo

// std__memory__weak_ptr_construct.cpp
// compile with: /EHsc
#include <memory>
#include <iostream>

int main()
{
    std::weak_ptr<int> wp0;
    std::cout << "wp0.expired() == " << std::boolalpha
        << wp0.expired() << std::endl;

    std::shared_ptr<int> sp1(new int(5));
    std::weak_ptr<int> wp1(sp1);
    std::cout << "*wp1.lock() == "
        << *wp1.lock() << std::endl;

    std::weak_ptr<int> wp2(wp1);
    std::cout << "*wp2.lock() == "
        << *wp2.lock() << std::endl;

    return (0);
}

wp0.expired() == true
*wp1.lock() == 5
*wp2.lock() == 5

~weak_ptr

Destrói um weak_ptr.

~weak_ptr();

Comentários

O destruidor destrói esse weak_ptr, mas não tem qualquer efeito na contagem de referência do objeto para o qual o ponteiro armazenado aponta.

Confira também

Referência de Arquivos de Cabeçalho
<memory>
shared_ptr classe