0Pricing
C++ Academy · Aula

shared_ptr e weak_ptr: propriedade partilhada

Partilhe a propriedade com contagem de referências e desfaça ciclos com weak_ptr

shared_ptr e weak_ptr: propriedade partilhada é uma aula grátis de C++ Academy no CoddyKit. Esta é a aula 3 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de C++ Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de C++ Academy inclui 4 aulas no total.

Compartilhando um objeto

Às vezes, várias partes do programa precisam manter um objeto vivo. std::shared_ptr<T> gerencia a posse compartilhada com contagem de referências.

Criando um shared_ptr

Use std::make_shared — ele aloca o bloco de controle e o objeto em uma única alocação.

#include <memory>
auto s = std::make_shared<Widget>(42);
std::cout << s.use_count();   // 1

Copiar compartilha a posse

Copiar um shared_ptr incrementa a contagem de referências. Destruí-lo ou atribuir-lhe outro valor a decrementa. Quando a contagem chega a 0, o objeto é excluído.

auto a = std::make_shared<Widget>();
auto b = a;                  // ref count is now 2
std::cout << a.use_count();  // 2

Como funciona internamente

Um shared_ptr contém dois ponteiros: um para o objeto e outro para um bloco de controle que contém as contagens de referências. O bloco de controle é alocado na memória dinâmica.

Contagem de referências atômica

A contagem de referências usa operações atômicas para que shared_ptrs possam ser copiados com segurança entre linhas de execução. No entanto, o próprio objeto apontado não é automaticamente seguro para linhas de execução.

Redefinindo e reatribuindo

Atribuir um novo valor decrementa a contagem de referências antiga e incrementa a nova. reset() deixa o shared_ptr vazio.

shared_ptr a partir de ponteiro bruto (evite)

Não construa dois shared_ptr a partir do mesmo ponteiro bruto — cada um teria seu próprio bloco de controle. Use sempre make_shared.

// BUG
Widget* raw = new Widget();
std::shared_ptr<Widget> a(raw);
std::shared_ptr<Widget> b(raw);   // disaster: two control blocks

O problema dos ciclos

Dois shared_ptr que fazem referência um ao outro formam um ciclo — a contagem de referências de nenhum deles chega a zero, e nenhum é liberado. Vazamento de memória.

struct Node {
    std::shared_ptr<Node> next;
};
auto a = std::make_shared<Node>();
auto b = std::make_shared<Node>();
a->next = b;
b->next = a;     // cycle — never freed

Quebrando ciclos com weak_ptr

std::weak_ptr<T> observa um shared_ptr sem participar da contagem de referências. Use um lado de uma relação como referência fraca para quebrar o ciclo.

struct Node {
    std::shared_ptr<Node> next;
    std::weak_ptr<Node>  prev;     // weak — does not own
};

Usando weak_ptr

Não é possível desreferenciar um weak_ptr diretamente. Chame lock() para obter um shared_ptr (ou um valor vazio se o objeto tiver sido destruído).

std::weak_ptr<Widget> w = sharedPtr;
if (auto p = w.lock()) {
    p->use();   // safe — we have a shared_ptr now
} else {
    std::cout << "object expired";
}

Custo em comparação com unique_ptr

shared_ptr é maior (dois ponteiros + bloco de controle) e mais lento (contagem atômica de referências). Use-o somente quando a propriedade realmente precisar ser compartilhada.

Verificação rápida

Qual é o caso de uso típico de std::weak_ptr?

Recapitulação

shared_ptr acompanha a propriedade usando uma contagem atômica de referências. Use make_shared, tome cuidado com ciclos e desfaça-os com weak_ptr. Prefira unique_ptr quando não for necessário compartilhar.

Perguntas Frequentes

A aula “shared_ptr e weak_ptr: propriedade partilhada” é grátis?

Sim — o texto completo de “shared_ptr e weak_ptr: propriedade partilhada” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de C++ Academy, atualize para CoddyKit PRO. O curso de C++ Academy inclui 4 aulas no total.

O que vou aprender em “shared_ptr e weak_ptr: propriedade partilhada”?

Partilhe a propriedade com contagem de referências e desfaça ciclos com weak_ptr Você pratica C++ Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar C++ Academy?

Nenhuma experiência prévia é necessária. C++ Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 3 de 4.

Quanto tempo leva a aula “shared_ptr e weak_ptr: propriedade partilhada”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de C++ Academy?

Sim. Cada aula de C++ Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

  1. Por que os ponteiros inteligentes substituem new e delete brutos
  2. unique_ptr: propriedade exclusiva
  3. shared_ptr e weak_ptr: propriedade partilhada
  4. Eliminadores personalizados e funções make
← Voltar para C++ Academy