C++ Academy · Aula

Erros comuns de memória

Evite vazamentos e ponteiros pendentes

Erros comuns de memória é uma aula grátis de C++ Academy no CoddyKit. Esta é a aula 4 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.

Vazamentos de memória

Um vazamento de memória acontece quando a memória dinâmica é alocada, mas nunca liberada. O programa continua consumindo memória que já não consegue acessar.

void leak() {
    int* p = new int(5);
    // missing delete p;  -> leaked
}

Ponteiros pendentes

Um ponteiro pendente aponta para uma memória que já foi liberada. Desreferenciá-lo resulta em comportamento indefinido.

int* p = new int(7);
delete p;
// *p = 3;   // BUG: dangling access

Liberação dupla

Chamar delete duas vezes no mesmo ponteiro corrompe a memória dinâmica e frequentemente faz o programa falhar.

int* p = new int(1);
delete p;
// delete p;   // BUG: double free

Uso após liberação

Ler ou escrever por meio de um ponteiro depois que o objeto foi excluído é um uso após liberação — uma fonte comum de vulnerabilidades de segurança.

Estouro da área de armazenamento

Escrever além do fim de uma matriz sobrescreve memória não relacionada. Permaneça sempre dentro dos limites.

int a[3] = {1, 2, 3};
// a[3] = 99;   // BUG: out of bounds

delete incompatível

Usar delete em uma alocação feita com new[] (ou o contrário) resulta em comportamento indefinido. Mantenha-os associados.

int* arr = new int[4];
// delete arr;   // BUG: should be delete[] arr;
delete[] arr;     // correct

Ponteiros não inicializados

Um ponteiro não inicializado contém lixo. Sempre o inicialize com um endereço válido ou nullptr.

#include <iostream>

int main() {
    int* p = nullptr;   // safe default
    if (!p) std::cout << "not set\n";
}

Retorno de endereços locais

Retornar o endereço de uma variável local da pilha cria instantaneamente um ponteiro pendente, pois a variável local morre no retorno.

int* bad() {
    int x = 10;
    return &x;   // BUG: x is gone
}

Ponteiros inteligentes evitam vazamentos

Substituir proprietários brutos por std::unique_ptr elimina a maioria dos vazamentos e das liberações duplas: a limpeza é automática e ocorre uma única vez.

#include <iostream>
#include <memory>

int main() {
    auto p = std::make_unique<int>(5);
    std::cout << *p << "\n";
}   // freed exactly once, automatically

Ferramentas para encontrar erros

Ferramentas como AddressSanitizer e Valgrind detectam vazamentos, liberações duplas e acessos fora dos limites em tempo de execução. Inclua-as nos seus testes.

Prevenir é melhor que detectar

A melhor solução é evitar completamente a propriedade bruta: use contêineres como std::vector e ponteiros inteligentes para que a biblioteca gerencie a memória corretamente por você.

Verificação rápida

Teste sua compreensão dos erros de memória.

Recapitulação

Você aprendeu os erros clássicos de memória: vazamentos, ponteiros pendentes, liberação dupla, uso após liberação, estouros da área de armazenamento e delete incompatível. Evite-os com ponteiros inteligentes e contêineres, e detecte os demais com ferramentas de sanitização e Valgrind.

Perguntas Frequentes

A aula “Erros comuns de memória” é grátis?

Sim — o texto completo de “Erros comuns de memória” é 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 “Erros comuns de memória”?

Evite vazamentos e ponteiros pendentes 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 4 de 4.

Quanto tempo leva a aula “Erros comuns de memória”?

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

← Voltar para C++ Academy