Principais erros de desenvolvedores C++ iniciantes: de A a Z

Introdução: Por que os iniciantes tropeçam em C++?

C++ é uma linguagem poderosa, mas exigente. Ela dá ao desenvolvedor controle total sobre a memória e o desempenho, mas essa liberdade se transforma em várias armadilhas. De acordo com pesquisas do Stack Overflow, mais de 60% dos desenvolvedores C++ iniciantes enfrentam vazamentos de memória e comportamento indefinido (undefined behavior) nos primeiros meses de trabalho.

Neste artigo, analisaremos os principais erros de desenvolvedores C++ iniciantes — desde o gerenciamento de memória até as nuances do trabalho com ponteiros. Você aprenderá como evitá-los e escrever um código mais seguro e eficiente.

1. Vazamentos de memória e gerenciamento incorreto de recursos

O erro mais comum é esquecer de liberar a memória alocada com new. Em C++ não há coletor de lixo, portanto, cada new exige um delete correspondente.

Exemplo de código incorreto:

void leakyFunction() {\n    int* ptr = new int(42);\n    // ... algum código que pode lançar uma exceção\n    // Esqueceu de delete ptr;\n}

Se uma exceção ocorrer na função antes do delete, a memória vazará para sempre.

Como corrigir:

\n
• Use ponteiros inteligentes (std::unique_ptr, std::shared_ptr) — eles liberam a memória automaticamente.
\n
• RAII (Resource Acquisition Is Initialization) — aloque recursos no construtor, libere no destrutor.
\n

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

2. Comportamento indefinido (Undefined Behavior)

C++ está cheio de situações em que o código compila, mas faz qualquer coisa — desde funcionar corretamente até travar ou formatar o disco rígido. Iniciantes frequentemente ignoram esses "detalhes".

Casos típicos:

\n
• Uso de variáveis não inicializadas — seu valor pode ser qualquer coisa (lixo).
\n
• Acesso fora dos limites do array — arr[10] com tamanho de 10 elementos.
\n
• Desreferenciamento de ponteiro nulo — int* p = nullptr; *p = 5;
\n
• Estouro de inteiros com sinal — int x = INT_MAX; x++;
\n

Exemplo com variável não inicializada:

int main() {\n    int x; // não inicializada\n    std::cout << x; // UB: pode exibir 0, 42, ou travar o programa\n    return 0;\n}

Solução: Sempre inicialize as variáveis. Use int x = 0; ou int x{}; (value-initialization).

3. Erros com ponteiros e referências

Ponteiros são um dos tópicos mais difíceis para iniciantes. Erros aqui levam a travamentos e bugs difíceis de encontrar.

Top 3 erros:

\n
• Ponteiros pendentes (dangling pointers) — ponteiro referenciando memória já liberada.
\n
• Vazamento de ponteiro para variável local — retornar o endereço de uma variável local de uma função.
\n
• Confusão entre ponteiro e referência — uma referência não pode ser reatribuída, um ponteiro pode.
\n

Exemplo de retorno de endereço de variável local:

int* badFunction() {\n    int local = 10;\n    return &local; // ERRO: local será destruída após sair da função\n}\n\nint main() {\n    int* ptr = badFunction();\n    std::cout << *ptr; // UB: ponteiro pendente\n}

Abordagem correta: Retorne o valor por cópia, use std::unique_ptr ou passe o resultado por parâmetro de referência.

void safeFunction(int& result) {\n    result = 10; // passagem por referência\n}