Conteúdo do Curso

C++ Smart Pointers

1. Introdução a Ponteiros Inteligentes

Compreendendo Ponteiros Alocação Dinâmica de Memória A Necessidade de Ponteiros Inteligentes

2. Ponteiros Únicos

Introdução aos Ponteiros Únicos Movendo Ponteiros Únicos Aplicação para Ponteiros Únicos Passando Ponteiros Únicos Métodos de um Ponteiro Único

3. Ponteiros Compartilhados

Introdução aos Ponteiros Compartilhados Criando e Compartilhando Shared Pointers Referências Circulares e Shared Pointers

4. Ponteiros Fracos

Introdução a Ponteiros Fracos Criando e Usando Weak Pointers Quebrando Referências Circulares com Weak Pointers Funções Importantes de Ponteiros Weak

5. Tópicos Avançados

Fornecendo Destruidores Personalizados para Smart Pointers Considerações de Desempenho com Smart Pointers Visão Geral Ponteiros Compartilhados vs Únicos vs Weak 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


              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


              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


              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


              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

Pergunte à IA

Pergunte o que quiser ou experimente uma das perguntas sugeridas para iniciar nosso bate-papo