Common C Errors: The Beginner Mistakes and How to Fix Them

Every C programmer meets the same short list of mistakes, usually in the first week and occasionally a decade later. What makes them worth cataloguing is that most produce error messages that do not describe them - or, worse, no message at all.

Each entry below is a symptom, the cause behind it, and the fix.

Missing Semicolon and the Cascade

Symptom: a wall of errors, all reported on lines that look correct.

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

Cause: C ends statements with ;. Leave one out and the compiler glues the next line onto the current one, then reports confusion at the point where the combined text stops making sense - typically the following line.

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

Fix: when a batch of errors appears, fix only the first one and recompile. Everything after it may be fallout. And always check the line before the one the compiler names.

The same cascade comes from an unclosed brace or an unterminated /* comment, where the errors can land dozens of lines away.

#include <stdio.h>

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

One extra note: no semicolon after an if, for, while header, or a function definition's closing brace. if (x > 0); compiles fine and does nothing - the ; is the whole body.

Assignment Instead of Comparison

Symptom: a condition that is always true, or a variable that mysteriously changes.

int x = 5;
if (x = 10) {              /* assigns 10, then tests 10 -> true */
    printf("x is ten\n");  /* always prints; x is now 10 */
}

Cause: = assigns, == compares. The assignment's value is the assigned value, so if (x = 10) tests 10, which is nonzero, which is true. The compiler accepts it because it is occasionally what people mean.

Fix: use == in every condition, and turn on -Wall so the compiler warns:

warning: suggest parentheses around assignment used as truth value

#include <stdio.h>

int main(void) {
    int x = 5;

    if (x == 10) {
        printf("x is ten\n");
    } else {
        printf("x is %d, not ten\n", x);
    }
    return 0;
}

If you genuinely mean assignment inside a condition - common with while ((c = getchar()) != EOF) - the extra parentheses say so and silence the warning.

Implicit Declaration of a Function

Symptom:

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

...followed sometimes by strange runtime results or a link error.

Cause: the compiler met a call to a function it has no declaration for. In pre-C99 dialects it assumed the function returned int and carried on; on 64-bit systems that assumption truncates a returned pointer to 32 bits, which is how a missing <stdlib.h> turns malloc into a crash.

Fix: include the right header.

For your own functions, the same warning means you called one before defining it. Put a prototype above main:

#include <stdio.h>

int triple(int n);      /* prototype: declared before use */

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

int triple(int n) {     /* definition, after main */
    return n * 3;
}

scanf Without the &

Symptom: the program crashes on input, or reads nothing and leaves the variable unchanged.

int age;
scanf("%d", age);     /* missing & : passes the value, not the address */

Cause: scanf writes into your variable, so it needs the variable's address. Passing age hands over whatever garbage was in it and scanf treats that as a place to write, which is usually a segfault.

Fix: & before the variable - for every type except an array, which is already an address:

#include <stdio.h>

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

    /* Reading from a string here so the example runs without input */
    sscanf("30 1.82 Alex", "%d %lf %49s", &age, &height, name);
    /*                                    ^    ^        ^
       & for int, & for double, no & for the array                */

    printf("%s is %d and %.2f m tall\n", name, age, height);
    return 0;
}

Two adjacent traps in the same family: use %lf for a double in scanf (%f there means float, and writing a float's worth of bytes into a double leaves it wrong), and always bound a %s with a width - %49s for a 50-byte buffer - or a long word overruns it.

Better still: read a whole line with fgets and parse it, which cannot overflow and does not leave stray input in the buffer. More on both in scanf.

Comparing Strings with ==

Symptom: two strings that clearly match compare as different.

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

if (a == b) {              /* comparing two addresses: false */
    printf("same\n");
}

Cause: a C string is not a value, it is a pointer to the first character. == compares the pointers. Two arrays holding identical text live at different addresses, so the test is false. (Confusingly, comparing two identical literals sometimes gives true, because the compiler may store one copy - which makes the bug intermittent.)

Fix: strcmp, and remember it returns 0 for equal:

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

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

    printf("a == b (pointers): %s\n", (a == b) ? "true" : "false");
    printf("strcmp(a, b) == 0: %s\n", (strcmp(a, b) == 0) ? "true" : "false");
    printf("strcmp(a, c) == 0: %s\n", (strcmp(a, c) == 0) ? "true" : "false");

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

The inverted reading catches people too: if (strcmp(a, b)) is true when the strings differ, since a nonzero result means "not equal". Always write the == 0 explicitly.

Integer Division

Symptom: an average of 0, a percentage that is always 0 or 100, a ratio that lost its fraction.

int correct = 7, total = 10;
double score = correct / total;      /* 0.0, not 0.7 */

Cause: both operands are int, so C does integer division and truncates before the result is assigned to a double. 7 / 10 is 0; converting 0 to double is 0.0.

Fix: make one operand floating point before the division:

#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;
}

Casting one operand promotes the other automatically. Casting the result is too late - the truncation already happened. See type casting.

The same trap hides in expressions like (a + b) / 2 for a midpoint and 1 / 2 * x, which is always 0 regardless of x.

Missing or Wrong return

Symptom: a function returns a plausible-looking wrong number, different each run or each build.

int add(int a, int b) {
    int sum = a + b;
    /* no return statement */
}

Cause: reaching the end of a non-void function without returning gives an unspecified value - in practice whatever happened to be in the return register. It is undefined behavior if the caller uses it.

The sneakier form returns on some paths and not others:

int classify(int n) {
    if (n > 0) return 1;
    if (n < 0) return -1;
    /* n == 0 falls off the end */
}

Fix: return on every path, and compile with -Wall - GCC's "control reaches end of non-void function" catches both versions.

#include <stdio.h>

int classify(int n) {
    if (n > 0) {
        return 1;
    }
    if (n < 0) {
        return -1;
    }
    return 0;          /* the path that was missing */
}

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

Uninitialized Variables

Symptom: garbage output, or results that change between runs and between optimization levels.

int total;                       /* contains whatever was on the stack */
for (int i = 1; i <= 5; i++) {
    total += i;                  /* adding to garbage */
}
printf("%d\n", total);           /* some enormous number */

Cause: local variables are not zeroed. A global or static variable is set to zero automatically; a local one starts as whatever bytes were already at that stack address.

Fix: initialize at the point of declaration. It costs nothing and removes the whole class of bug:

#include <stdio.h>

int main(void) {
    int total = 0;              /* initialized */
    int values[5] = {0};        /* every element zeroed */
    char name[32] = "";         /* empty string, not garbage */

    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' (length %zu)\n", name, sizeof name);
    return 0;
}

-Wall -Wextra warns about many of these ("may be used uninitialized"), and -fsanitize=memory or valgrind catches the rest. This one is especially nasty because an uninitialized pointer leads straight to a segmentation fault.

Off-by-One

Symptom: the last item is missed, or one element too many is touched and the program misbehaves later.

int arr[5];
for (int i = 0; i <= 5; i++) {   /* touches arr[5], which does not exist */
    arr[i] = i;
}

Cause: an n-element array has indices 0 through n - 1. <= runs one extra pass.

Fix: the i < n pattern, and compute n from the array rather than writing the number twice:

#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 need one extra byte for the terminating '\0' */
    char word[6];                  /* 5 letters + terminator */
    strcpy(word, "hello");
    printf("'%s' uses %zu of %zu bytes\n", word, strlen(word) + 1, sizeof word);
    return 0;
}

The string version - forgetting room for '\0' - is the same error wearing a different hat, and char word[5] with "hello" in it is a buffer overrun.

Two Smaller Ones Worth Knowing

Semicolon after a loop header. for (int i = 0; i < 10; i++); followed by a braced block runs the loop ten times doing nothing, then runs the block once. It compiles cleanly.

sizeof on a pointer. Inside a function, an array parameter is a pointer, so sizeof(arr) is the pointer's size (8 bytes), not the array's. Pass the length as a separate argument:

#include <stdio.h>

void report(int arr[], size_t n) {
    printf("sizeof(arr) inside the function: %zu\n", sizeof arr);
    printf("actual element count passed in:  %zu\n", n);
}

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

The Habit That Prevents Most of This

Compile with warnings on, from the very first program:

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

-Wall -Wextra catches the assignment-in-condition, the missing return, the uninitialized read, the unused variable, and the printf specifier that does not match its argument. Adding -fsanitize=address,undefined during development catches nearly all of the rest at the moment they happen.

Treat every warning as an error you have not hit yet. A C program that compiles with no warnings is not guaranteed correct - but almost every C program that crashes was warning about something first.