Common C Compilation Errors: Syntax, Linker & Runtime — With Fixes

Root cause: Every C statement must end with a semicolon. The compiler doesn't detect the missing semicolon until it sees the next token and realizes the statement was never closed — which is why the error points to the line after the mistake.

printf("Hello")  // ← missing ;
return 0;

printf("Hello");  // ← semicolon added
return 0;

Root cause: Every opening { must have a matching }. This error appears at the end of the file because the compiler reaches EOF while still waiting to close an open brace.

int main() {
    printf("Hi\n");
    return 0;
// ← missing closing }

int main() {
    printf("Hi\n");
    return 0;
}  // ← closing brace added

Use an editor with bracket matching (VS Code, Vim with %) to spot mismatches instantly.

Root cause: In C, every variable must be declared with its type before it can be used. Using a variable name that hasn't been declared — or that was declared in a different scope — produces this error.

int main() {
    x = 5;  // x not declared
    return 0;
}

int main() {
    int x = 5;  // declare type first
    return 0;
}

Root cause: C is statically typed. Assigning a value of one type to a variable of an incompatible type is a compile-time error. Common triggers: assigning a string literal to an int, or passing the wrong pointer type to a function.

int age = "twenty-five";  // string → int

int age = 25;          // integer literal
char *name = "Alice";  // string → char*

Root cause: You included <math.h> (which provides the declaration of sqrt) but didn't tell the linker to include the math library (libm) that contains the implementation. The -lm flag must come at the end of the GCC command, after the source files.

gcc prog.c -o prog
undefined reference to 'sqrt'

gcc prog.c -o prog -lm
# -lm links libm (math library)

Root cause: Your project has multiple .c files but you only compiled one of them. The linker can see the call to my_function in main.o but it's not in any of the object files it was given.

gcc main.c -o app
undefined reference to 'my_function'

gcc main.c utils.c -o app
# compile ALL .c files together

Root cause: You wrote a function prototype (declaration) but never wrote the function body (definition). The compiler accepted the call because the prototype exists, but the linker can't find the actual code.

void greet();  // declaration only

int main() {
    greet();   // linker: where is greet()?
    return 0;
}
// greet body is missing!

void greet();  // declaration

int main() {
    greet();
    return 0;
}

void greet() {         // definition added
    printf("Hello!\n");
}

Root cause: You called a function without the compiler having seen its declaration first. Usually means a missing #include. In C99 and later, implicit declarations are invalid — what used to be a warning is now effectively an error.

// #include <stdio.h> missing!
int main() {
    printf("Hi\n");
    return 0;
}

#include <stdio.h>   // declares printf
int main() {
    printf("Hi\n");
    return 0;
}

Root cause: A variable was declared but never used. This is almost always either dead code (a variable left over from a refactor) or a logic error (you intended to use the variable somewhere but forgot).

int main() {
    int count = 0;  // declared but never used
    printf("Done\n");
    return 0;
}

int main() {
    // Remove unused variable, or use it:
    int count = 0;
    printf("Count: %d\n", count);
    return 0;
}

Root cause: A function declared to return a value (e.g. int) has an execution path that reaches the end without a return statement. The returned value is undefined — the function returns garbage.

int add(int a, int b) {
    int result = a + b;
    // forgot: return result;
}

int add(int a, int b) {
    int result = a + b;
    return result;  // return value added
}

Root cause: The format specifier in printf doesn't match the type of the argument. %d expects int, %f expects float/double, %s expects char*. A mismatch produces garbage output — or a crash on some platforms.

double pi = 3.14;
printf("%d\n", pi);  // %d ≠ double

double pi = 3.14;
printf("%f\n", pi);  // %f for double

Root cause: The program tried to read or write a memory address it doesn't have permission to access. The most common causes are: dereferencing a NULL pointer, accessing an array out of bounds, or using memory after it has been freed.

int *p = NULL;
*p = 42;   // segfault: writing to address 0

int value = 0;
int *p = &value;   // point to valid memory
*p = 42;

gcc -g -fsanitize=address prog.c -o prog && ./prog
ERROR: AddressSanitizer: SEGV on unknown address 0x000000000000 (pc 0x... )
    #0 0x... in main prog.c:3
# AddressSanitizer tells you the exact line

Root cause: A recursive function calls itself without ever reaching a base case. Each call adds a stack frame; eventually the stack runs out of space and the OS kills the process.

int factorial(int n) {
    // missing base case!
    return n * factorial(n - 1);
}

int factorial(int n) {
    if (n <= 1) return 1;  // base case
    return n * factorial(n - 1);
}

Root cause: Memory allocated with malloc() was never released with free(). The program doesn't crash — it silently consumes memory that is never returned to the OS. In long-running programs (servers, daemons), this eventually exhausts available memory.

int *arr = malloc(10 * sizeof(int));
arr[0] = 42;
// free(arr) missing — memory leak

int *arr = malloc(10 * sizeof(int));
arr[0] = 42;
free(arr);   // always free what you malloc