Funções Importantes de Ponteiros Weak

A função expired()

Antes de chamar lock(), você pode verificar se um ponteiro fraco ainda é válido usando o método expired(). Esta função retorna true se o objeto foi destruído e false caso contrário.

expired_function

// Call `expired()` before `lock()`

if (!p_weak.expired())

{

// Lock only if the object is still alive

auto p_shared = p_weak.lock();

p_shared->update();

}

else

{

std::cout << "Object no longer exists" << std::endl;

}


              1234567891011
            
// Call `expired()` before `lock()`
if (!p_weak.expired()) 
{
    // Lock only if the object is still alive
    auto p_shared = p_weak.lock();
    p_shared->update();
}
else
{
    std::cout << "Object no longer exists" << std::endl;
}

Chamar expired() antes de bloquear o ponteiro fraco ajuda a determinar se o objeto referenciado ainda existe.

A função use_count()

Embora um ponteiro fraco não afete a contagem de referência de um objeto, pode ser útil saber quantas instâncias de std::shared_ptr estão gerenciando o mesmo objeto. A função use_count() retorna esse número.

use_count_function

std::shared_ptr<int> p_shared = std::make_shared<int>(42);

std::weak_ptr<int> p_weak(sharedPtr);

// Should output one

std::cout << p_weak.use_count() << std::endl;


              12345
            
std::shared_ptr<int> p_shared = std::make_shared<int>(42);
std::weak_ptr<int> p_weak(sharedPtr);

// Should output one
std::cout << p_weak.use_count() << std::endl;

A função reset()

Para liberar um ponteiro fraco de observar um objeto, use a função reset(). Isso faz com que o ponteiro fraco fique vazio, ou seja, ele não aponta mais para nenhum objeto.

reset_function

std::weak_ptr<int> p_weak(sharedPtr);

// After this, `p_weak` no longer observes the `p_shared` object

p_weak.reset();


              1234
            
std::weak_ptr<int> p_weak(sharedPtr);

// After this, `p_weak` no longer observes the `p_shared` object
p_weak.reset();

A função swap()

A função swap() pode ser usada para trocar o conteúdo de dois ponteiros fracos. Isso é particularmente útil quando você deseja alterar os objetos que os dois ponteiros fracos estão observando, sem alterar a propriedade ou o tempo de vida dos objetos dinâmicos.

swap_function

std::shared_ptr<int> p_shared_A = std::make_shared<int>(10);

std::shared_ptr<int> p_shared_B = std::make_shared<int>(20);

std::weak_ptr<int> p_weak_A(p_shared_A);

std::weak_ptr<int> p_weak_B(p_shared_B);

// Swaps the objects `p_weak_A` and `p_weak_B`

p_weak_A.swap(weakPtrB);


              12345678
            
std::shared_ptr<int> p_shared_A = std::make_shared<int>(10);
std::shared_ptr<int> p_shared_B = std::make_shared<int>(20);

std::weak_ptr<int> p_weak_A(p_shared_A);
std::weak_ptr<int> p_weak_B(p_shared_B);

// Swaps the objects `p_weak_A` and `p_weak_B`
p_weak_A.swap(weakPtrB);

inicialmente p_weak_A observa o objeto gerenciado por p_shared_A, enquanto p_weak_B observa o objeto gerenciado por p_shared_B.

Após chamar swap(), p_weak_A começa a observar o objeto gerenciado por p_shared_B, e p_weak_B observa o objeto gerenciado por p_shared_A.

Tudo estava claro?

Obrigado pelo seu feedback!

Seção 4. Capítulo 4