Conteúdo do Curso
C++ Smart Pointers
C++ Smart Pointers
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; }
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;
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();
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);
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.
Obrigado pelo seu feedback!
