Error Handling in C

How C handles errors

Many modern languages have try and catch for errors. C does not. Instead, C uses a simpler, older approach: a function tells you it failed through its return value, and it is your job to check that value every time.

On top of that, many standard functions set a special global variable called errno that carries a code explaining why they failed. Together, return-value checking and errno are how reliable C programs stay safe.

Checking return values

The core habit is: after calling a function that can fail, immediately check what it returned before using the result.

#include <stdio.h>
int main() {
    FILE *fp = fopen("data.txt", "r");
    if (fp == NULL) {              // check before using
        printf("Error: could not open file.\n");
        return 1;
    }
    // safe to use fp here
    fclose(fp);
    return 0;
}

errno, perror and strerror

When a standard function fails, it often sets errno. You can print a readable description of it in two ways.

#include <stdio.h>
#include <errno.h>
#include <string.h>
int main() {
    FILE *fp = fopen("missing.txt", "r");
    if (fp == NULL) {
        perror("fopen failed");              // message + errno text
        printf("Details: %s\n", strerror(errno)); // same, as string
        return 1;
    }
    fclose(fp);
    return 0;
}

Handling file errors

File work is a classic place for errors: the file may be missing, locked, or full. Always check fopen, and check reads and writes too.

FILE *fp = fopen("data.txt", "w");
if (fp == NULL) {
    perror("Cannot open data.txt");
    return 1;
}
if (fprintf(fp, "Hello\n") < 0) {   // writing can fail too
    perror("Write failed");
}
fclose(fp);

See file handling in C for the full set of file functions.

Handling memory errors

malloc can fail when memory runs out. Using its result without checking is a common crash.

#include <stdio.h>
#include <stdlib.h>
int main() {
    int *arr = malloc(100 * sizeof(int));
    if (arr == NULL) {                // check!
        printf("Error: out of memory.\n");
        return 1;
    }
    // use arr safely...
    free(arr);
    return 0;
}

See dynamic memory in C for more on malloc and free.

Best practices

• Check the return value of every function that can fail.
• Handle the error close to where it happens, with a clear message.
• Read errno immediately, before another call overwrites it.
• Free any resources (files, memory) before exiting on an error.
• Return a non-zero code from main to signal failure to the system.

Common mistakes

• Ignoring return values and using a NULL or invalid result.
• Reading errno too late, after another call has changed it.
• Printing an error but then continuing as if nothing failed.
• Leaking files or memory by returning early without cleanup.

Summary

• C has no exceptions — errors are reported through return values.
• Many functions set errno; read it right after the failing call.
• perror prints an error message; strerror returns it as a string.
• Always check fopen, malloc, reads and writes.
• Clean up resources and return a non-zero code on failure.