Erros comuns em C: os deslizes de iniciante e como corrigi-los

Todo programador C encontra a mesma listinha de erros, geralmente na primeira semana e ocasionalmente uma década depois. O que os torna dignos de catálogo é que a maioria produz mensagens de erro que não os descrevem - ou, pior, nenhuma mensagem.

Cada entrada abaixo é um sintoma, a causa por trás dele e a solução.

Ponto e vírgula faltando e a cascata

Sintoma: uma parede de erros, todos reportados em linhas que parecem corretas.

program.c:6:5: error: expected ';' before 'printf'
program.c:7:5: error: expected declaration specifiers before 'return'

Causa: C termina instruções com ;. Deixe um de fora e o compilador cola a próxima linha na atual, e depois reporta a confusão no ponto em que o texto combinado deixa de fazer sentido - tipicamente na linha seguinte.

int main(void) {
    int x = 5      /* ponto e vírgula faltando */
    printf("%d\n", x);
    return 0;
}

Solução: quando aparecer um monte de erros, corrija só o primeiro e recompile. Tudo depois dele pode ser consequência. E confira sempre a linha anterior à que o compilador aponta.

A mesma cascata vem de uma chave não fechada ou de um comentário /* não encerrado, casos em que os erros podem cair dezenas de linhas adiante.

#include <stdio.h>

int main(void) {
    int x = 5;
    printf("%d\n", x);
    return 0;
}

Uma observação extra: nada de ponto e vírgula depois do cabeçalho de um if, for ou while, nem depois da chave de fechamento da definição de uma função. if (x > 0); compila normalmente e não faz nada - o ; é o corpo inteiro.

Atribuição no lugar de comparação

Sintoma: uma condição sempre verdadeira, ou uma variável que muda misteriosamente.

int x = 5;
if (x = 10) {              /* atribui 10 e depois testa 10 -> verdadeiro */
    printf("x é dez\n");   /* imprime sempre; x agora é 10 */
}

Causa: = atribui, == compara. O valor da atribuição é o valor atribuído, então if (x = 10) testa 10, que é diferente de zero, o que é verdadeiro. O compilador aceita porque de vez em quando é isso que as pessoas querem.

Solução: use == em toda condição e ligue o -Wall para o compilador avisar:

warning: suggest parentheses around assignment used as truth value

#include <stdio.h>

int main(void) {
    int x = 5;

    if (x == 10) {
        printf("x é dez\n");
    } else {
        printf("x é %d, não dez\n", x);
    }
    return 0;
}

Se você realmente quer uma atribuição dentro de uma condição - comum em while ((c = getchar()) != EOF) - os parênteses extras dizem isso e silenciam o aviso.

Declaração implícita de uma função

Sintoma:

warning: implicit declaration of function 'printf'
warning: implicit declaration of function 'malloc'

...seguido às vezes de resultados estranhos em tempo de execução ou de um erro de ligação.

Causa: o compilador encontrou uma chamada a uma função para a qual não tem declaração. Em dialetos anteriores ao C99, ele supunha que a função retornava int e seguia em frente; em sistemas de 64 bits essa suposição trunca um ponteiro retornado para 32 bits, que é como um <stdlib.h> esquecido transforma o malloc num travamento.

Solução: inclua o cabeçalho certo.

Para funções suas, o mesmo aviso significa que você chamou uma antes de defini-la. Coloque um protótipo acima de main:

#include <stdio.h>

int triple(int n);      /* protótipo: declarado antes do uso */

int main(void) {
    printf("%d\n", triple(7));
    return 0;
}

int triple(int n) {     /* definição, depois de main */
    return n * 3;
}

scanf sem o &

Sintoma: o programa trava na entrada, ou não lê nada e deixa a variável intacta.

int age;
scanf("%d", age);     /* falta o & : passa o valor, não o endereço */

Causa: scanf escreve dentro da sua variável, então precisa do endereço dela. Passar age entrega o lixo que estava lá dentro, e o scanf trata isso como um lugar para escrever, o que normalmente é uma falha de segmentação.

Solução: & antes da variável - para todo tipo, exceto um array, que já é um endereço:

#include <stdio.h>

int main(void) {
    int    age = 0;
    double height = 0.0;
    char   name[50] = "";

    /* Lendo de uma string aqui para o exemplo rodar sem entrada */
    sscanf("30 1.82 Alex", "%d %lf %49s", &age, &height, name);
    /*                                    ^    ^        ^
       & para int, & para double, sem & para o array                */

    printf("%s tem %d anos e %.2f m de altura\n", name, age, height);
    return 0;
}

Duas armadilhas vizinhas da mesma família: use %lf para um double no scanf (%f ali significa float, e escrever o tanto de bytes de um float dentro de um double o deixa errado) e sempre limite um %s com uma largura - %49s para um buffer de 50 bytes - ou uma palavra longa o estoura.

Melhor ainda: leia uma linha inteira com fgets e a analise, o que não pode transbordar e não deixa entrada perdida no buffer. Mais sobre os dois em scanf.

Comparar strings com ==

Sintoma: duas strings que claramente coincidem são comparadas como diferentes.

char a[] = "hello";
char b[] = "hello";

if (a == b) {              /* comparando dois endereços: falso */
    printf("iguais\n");
}

Causa: uma string em C não é um valor, é um ponteiro para o primeiro caractere. == compara os ponteiros. Dois arrays com o mesmo texto vivem em endereços diferentes, então o teste é falso. (De forma confusa, comparar dois literais idênticos às vezes dá verdadeiro, porque o compilador pode guardar só uma cópia - o que torna o bug intermitente.)

Solução: strcmp, e lembre que ele retorna 0 para igual:

#include <stdio.h>
#include <string.h>

int main(void) {
    char a[] = "hello";
    char b[] = "hello";
    char c[] = "world";

    printf("a == b (ponteiros): %s\n", (a == b) ? "verdadeiro" : "falso");
    printf("strcmp(a, b) == 0: %s\n", (strcmp(a, b) == 0) ? "verdadeiro" : "falso");
    printf("strcmp(a, c) == 0: %s\n", (strcmp(a, c) == 0) ? "verdadeiro" : "falso");

    if (strcmp(a, b) == 0) {
        printf("As strings coincidem\n");
    }
    return 0;
}

A leitura invertida também pega gente: if (strcmp(a, b)) é verdadeiro quando as strings diferem, já que um resultado diferente de zero significa "não são iguais". Escreva sempre o == 0 explicitamente.

Divisão inteira

Sintoma: uma média de 0, uma porcentagem que é sempre 0 ou 100, uma razão que perdeu a fração.

int correct = 7, total = 10;
double score = correct / total;      /* 0.0, e não 0.7 */

Causa: os dois operandos são int, então C faz divisão inteira e trunca antes de o resultado ser atribuído a um double. 7 / 10 é 0; converter 0 para double é 0.0.

Solução: torne um dos operandos de ponto flutuante antes da divisão:

#include <stdio.h>

int main(void) {
    int correct = 7, total = 10;

    printf("correct / total            = %.4f\n", (double)(correct / total));
    printf("(double)correct / total    = %.4f\n", (double)correct / total);
    printf("correct / (double)total    = %.4f\n", correct / (double)total);
    printf("correct * 100.0 / total    = %.1f%%\n", correct * 100.0 / total);
    return 0;
}

Converter um operando promove o outro automaticamente. Converter o resultado é tarde demais - o truncamento já aconteceu. Veja conversão de tipos.

A mesma armadilha se esconde em expressões como (a + b) / 2 para um ponto médio e 1 / 2 * x, que é sempre 0 independentemente de x.

return ausente ou errado

Sintoma: uma função retorna um número errado com cara de plausível, diferente a cada execução ou a cada compilação.

int add(int a, int b) {
    int sum = a + b;
    /* nenhuma instrução return */
}

Causa: chegar ao fim de uma função não-void sem retornar dá um valor não especificado - na prática, o que por acaso estivesse no registrador de retorno. É comportamento indefinido se quem chamou usar esse valor.

A forma mais sorrateira retorna em alguns caminhos e em outros não:

int classify(int n) {
    if (n > 0) return 1;
    if (n < 0) return -1;
    /* n == 0 escorrega até o fim */
}

Solução: retorne em todo caminho e compile com -Wall - o "control reaches end of non-void function" do GCC pega as duas versões.

#include <stdio.h>

int classify(int n) {
    if (n > 0) {
        return 1;
    }
    if (n < 0) {
        return -1;
    }
    return 0;          /* o caminho que estava faltando */
}

int main(void) {
    printf("%d %d %d\n", classify(5), classify(-5), classify(0));
    return 0;
}

Variáveis não inicializadas

Sintoma: saída com lixo, ou resultados que mudam entre execuções e entre níveis de otimização.

int total;                       /* contém o que estava na pilha */
for (int i = 1; i <= 5; i++) {
    total += i;                  /* somando em cima de lixo */
}
printf("%d\n", total);           /* algum número enorme */

Causa: variáveis locais não são zeradas. Uma variável global ou static é posta em zero automaticamente; uma local começa com os bytes que já estavam naquele endereço da pilha.

Solução: inicialize no ponto da declaração. Não custa nada e elimina a classe inteira de bug:

#include <stdio.h>

int main(void) {
    int total = 0;              /* inicializada */
    int values[5] = {0};        /* todo elemento zerado */
    char name[32] = "";         /* string vazia, não lixo */

    for (int i = 1; i <= 5; i++) {
        total += i;
        values[i - 1] = i * i;
    }

    printf("total = %d\n", total);
    printf("values[4] = %d\n", values[4]);
    printf("name = '%s' (tamanho %zu)\n", name, sizeof name);
    return 0;
}

-Wall -Wextra avisa sobre muitos desses casos ("may be used uninitialized"), e -fsanitize=memory ou o valgrind pegam o resto. Esse é especialmente cruel porque um ponteiro não inicializado leva direto a uma falha de segmentação.

Deslocamento por um (off-by-one)

Sintoma: o último item é perdido, ou um elemento a mais é tocado e o programa se comporta mal depois.

int arr[5];
for (int i = 0; i <= 5; i++) {   /* toca arr[5], que não existe */
    arr[i] = i;
}

Causa: um array de n elementos tem índices de 0 a n - 1. <= executa uma passada a mais.

Solução: o padrão i < n, e calcule n a partir do array em vez de escrever o número duas vezes:

#include <stdio.h>
#include <string.h>

int main(void) {
    int arr[5];
    size_t n = sizeof arr / sizeof arr[0];

    for (size_t i = 0; i < n; i++) {
        arr[i] = (int)i * 10;
    }
    for (size_t i = 0; i < n; i++) {
        printf("%d ", arr[i]);
    }
    printf("\n");

    /* Strings precisam de um byte extra para o '\0' terminador */
    char word[6];                  /* 5 letras + terminador */
    strcpy(word, "hello");
    printf("'%s' usa %zu de %zu bytes\n", word, strlen(word) + 1, sizeof word);
    return 0;
}

A versão com strings - esquecer espaço para o '\0' - é o mesmo erro com outra roupa, e char word[5] com "hello" dentro é um estouro de buffer.

Dois menores que vale conhecer

Ponto e vírgula depois do cabeçalho de um laço. for (int i = 0; i < 10; i++); seguido de um bloco entre chaves executa o laço dez vezes sem fazer nada e depois executa o bloco uma vez. Compila sem reclamar.

sizeof num ponteiro. Dentro de uma função, um parâmetro de array é um ponteiro, então sizeof(arr) é o tamanho do ponteiro (8 bytes), não o do array. Passe o comprimento como um argumento separado:

#include <stdio.h>

void report(int arr[], size_t n) {
    printf("sizeof(arr) dentro da função: %zu\n", sizeof arr);
    printf("contagem real de elementos:   %zu\n", n);
}

int main(void) {
    int data[10] = {0};
    printf("sizeof(data) em main: %zu bytes\n", sizeof data);
    report(data, sizeof data / sizeof data[0]);
    return 0;
}

O hábito que evita a maior parte disso

Compile com os avisos ligados, desde o primeiro programa:

gcc -Wall -Wextra -g program.c -o program

-Wall -Wextra pega a atribuição dentro de condição, o return faltando, a leitura de variável não inicializada, a variável não usada e o especificador do printf que não bate com o argumento. Acrescentar -fsanitize=address,undefined durante o desenvolvimento pega quase todo o resto no momento em que acontece.

Trate todo aviso como um erro que você ainda não encontrou. Um programa em C que compila sem avisos não tem correção garantida - mas quase todo programa em C que trava estava avisando sobre alguma coisa antes.