Principais erros de desenvolvedores C++ iniciantes e como evitá-los

Principais erros de desenvolvedores C++ iniciantes

C++ é uma linguagem poderosa, mas exigente. Ela dá ao programador controle total sobre a memória e o desempenho, mas essa liberdade tem um alto custo em responsabilidade. Iniciantes frequentemente cometem os mesmos erros que levam a vazamentos de memória, comportamento indefinido e bugs difíceis de encontrar. Neste artigo, vamos analisar os 4 erros mais comuns de desenvolvedores C++ iniciantes e mostrar como evitá-los.

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

O problema mais comum é esquecer de chamar delete após new. Como resultado, a memória não é liberada e o aplicativo "consome" cada vez mais recursos.

Exemplo de erro:

void leakExample() {    int* ptr = new int(42);    // ... algum código ...    // Esqueceu o delete ptr;}

Cada chamada dessa função "perderá" 4 bytes. Em programas de longa duração, isso leva ao esgotamento da memória.

Solução correta — RAII e smart pointers:

#include <memory>

void safeExample() {    std::unique_ptr<int> ptr = std::make_unique<int>(42);    // A memória será liberada automaticamente ao sair da função}

Use std::unique_ptr para posse exclusiva e std::shared_ptr para acesso compartilhado. Nunca use new e delete puros em C++ moderno.

2. Confusão entre ponteiros e referências

Iniciantes frequentemente não entendem a diferença entre T* e T&. A principal diferença: uma referência não pode ser nullptr, não pode ser reatribuída e sempre aponta para um objeto válido.

Exemplo de confusão:

void process(int* ptr) {    if (ptr) {        *ptr = 10; // OK    }}

int main() {    int a = 5;    process(&a); // Funciona    process(nullptr); // Também "funciona", mas pode ser um bug}

Aqui a função aceita um ponteiro, mas logicamente espera um objeto válido. É melhor usar uma referência:

void process(int& ref) {    ref = 10; // Sempre seguro}

int main() {    int a = 5;    process(a); // Claro e explícito    // process(nullptr); // Erro de compilação — é o que queremos!}

Regra: use referências sempre que o objeto deve obrigatoriamente existir. Deixe os ponteiros para parâmetros opcionais ou arrays dinâmicos.

3. Ignorar a correção constante (const-correctness)

Muitos iniciantes esquecem o const. Isso faz com que funções não possam aceitar objetos temporários e o compilador não consiga otimizar o código.

Exemplo de erro:

void printVector(std::vector<int>& vec) {    for (int v : vec) {        std::cout << v << " ";    }}

int main() {    printVector({1, 2, 3}); // Erro! Não é possível ligar um objeto temporário a uma referência não-const}

Solução correta:

void printVector(const std::vector<int>& vec) {    for (int v : vec) {        std::cout << v << " ";    }}

int main() {    printVector({1, 2, 3}); // Funciona!}

Sempre adicione const aos parâmetros que não devem ser modificados. Isso torna o código mais seguro e claro.

4. Uso incorreto de strings e esquecimento do std::string

Iniciantes frequentemente usam C-strings (char*) e escrevem suas próprias funções para manipulá-las, embora C++ tenha a poderosa classe std::string.

Exemplo de código perigoso:

void unsafeConcat(char* dest, const char* src) {    strcat(dest, src); // Fácil de estourar o buffer!}

int main() {    char buffer[10];```