10 erros de iniciantes em C++: como não quebrar o código

Por que o C++ quebra até os experientes, e os iniciantes ainda mais

C++ é uma linguagem implacável. Ela lhe dá controle total sobre a memória, mas também exige disciplina absoluta. Se você está começando a aprender C++, provavelmente já se deparou com o fato de que o programa compila, mas trava com um erro, ou (o que é pior) funciona incorretamente sem nenhum erro. Isso não é culpa sua — é a natureza da linguagem. Mas podemos ajudá-lo a evitar os erros mais comuns em que todos os iniciantes pisam.

Neste artigo, analisaremos 10 erros críticos ao aprender C++ que transformam o código em uma mistura infernal de vazamentos de memória e comportamento indefinido. Vamos lá!

1. Esqueceu de liberar a memória: vazamento clássico

O erro mais popular de iniciantes em C++ é alocar memória dinâmica com new e esquecer o delete. O programa consome RAM como um aspirador de pó, e você nem percebe.

Exemplo ruim:

int* ptr = new int(42);\n// ... muito código ...\n// Esqueceu: delete ptr;

Resultado: vazamento de memória. O programa funciona, mas a cada chamada consome cada vez mais recursos. Em projetos modernos, isso é inaceitável.

Como corrigir:

\n
• Use ponteiros inteligentes (std::unique_ptr, std::shared_ptr) — eles liberam a memória automaticamente.
\n
• Se não tiver jeito sem new/delete — sempre coloque delete imediatamente após o último uso.
\n

#include <memory>\nstd::unique_ptr<int> ptr = std::make_unique<int>(42);\n// A memória será liberada automaticamente ao sair do escopo

2. Usar using namespace std; no escopo global

Esta linha é como uma bomba-relógio. Em pequenos exemplos de aprendizado, funciona, mas em um projeto real leva a conflitos de nomes.

Problema:

#include <iostream>\n#include <vector>\nusing namespace std;\n\n// Um ano depois, aparece uma classe vector no projeto\nclass vector { ... }; // Erro de compilação!

Os nomes de std (por exemplo, vector, cout) tornam-se globais, e qualquer classe sua com o mesmo nome causará colisão.

Melhor assim:

\n
• Escreva std::cout, std::vector explicitamente.
\n
• Ou use using std::cout; apenas para nomes específicos.
\n

3. Comportamento indefinido: um tiro no pé

O erro mais traiçoeiro ao aprender C++ é o comportamento indefinido (UB — Undefined Behavior). O compilador não emitirá erro, o programa pode funcionar, ou pode apagar seu disco rígido. É brincadeira, mas perto da verdade.

Exemplos de UB:

\n
• Acessar fora dos limites do array: int arr[5]; arr[10] = 42;
\n
• Desreferenciar ponteiro nulo: int* p = nullptr; *p = 5;
\n
• Usar uma variável antes da inicialização.
\n

int x; // não inicializada\nstd::cout << x; // UB: pode imprimir lixo, 0 ou causar crash

Dica: sempre inicialize as variáveis. Use std::array ou std::vector em vez de arrays brutos — eles verificam os limites (no modo debug).

4. Confusão entre ponteiro e referência

Iniciantes frequentemente não entendem a diferença entre int* p e int& ref. Erro: tentam reatribuir uma referência, ou esquecem de desreferenciar o ponteiro.

Erro típico:

void change(int* p) {\n    p = new int(10); // alteramos a cópia local do ponteiro, o original não mudou\n}\n\nint main() {\n    int* ptr = nullptr;\n    change(ptr);\n    std::cout << *ptr; // UB: ptr ainda é nullptr\n}

Como fazer certo: passe o ponteiro por referência (int*& p) ou use referências, se não precisar alterar o endereço.