C Error Handling

Error Handling in C

Error handling lets you detect and respond to problems in your program, like a file that can't be opened or memory that can't be allocated, so your program doesn't crash or behave unexpectedly.

Unlike some languages, C does not have built-in exception handling (like try/catch). Instead, C uses return values, global error codes, and helper functions like perror() and strerror().

Using Return Values

In the previous chapter, you learned that functions like fopen() return NULL when something goes wrong.

You can check for NULL using an if statement to detect and handle errors before your program crashes.

In the example below, we try to open a file that does not exist. Since fopen() fails, it returns NULL and we print an error message:

#include <stdio.h>

int main() {
  FILE *fptr = fopen("nothing.txt", "r");

  if (fptr == NULL) {
    printf("Error opening file.\n");
    return 1;
  }

  fclose(fptr);
  return 0;
}

Note: In the Read Files chapter, fclose() was inside an if...else statement, so it was only called when the file was opened. Here, we do not need the else: if fopen() fails, return 1 stops the program before it reaches fclose(). You will learn more about return values in the section below.

Return Error Codes From Your Own Functions

You can use the same idea in your own functions: return a value that tells the caller if something went wrong. A common way is to return 0 for success, and another number (like -1) for an error.

This function divides two numbers. If the second number is 0, it returns -1. Otherwise, it stores the result through a pointer (see Pass By Reference) and returns 0:

#include <stdio.h>

// Returns 0 if everything is OK, and -1 if b is 0
int divide(int a, int b, int *result) {
  if (b == 0) {
    return -1;
  }
  *result = a / b;
  return 0;
}

int main() {
  int result;

  if (divide(10, 0, &result) != 0) {
    printf("Error: Division by zero!\n");
    return 1;
  }

  printf("Result: %d\n", result);
  return 0;
}

The caller checks the returned value, and only uses result if the function returned 0.

Get More Details

If you want more details about what went wrong, you can use the perror() function.

It prints a custom error message followed by a description of the last error that occurred:

#include <stdio.h>

int main() {
  FILE *f = fopen("nothing.txt", "r");

  if (f == NULL) {
    perror("Error opening file");
    return 1;
  }

  fclose(f);
  return 0;
}

Using strerror() and errno

errno is a global variable that stores the error code from the last failed operation. You can include <errno.h> to access it, and strerror(errno) will convert the error code into a readable message:

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

int main() {
  FILE *f = fopen("nothing.txt", "r");

  if (f == NULL) {
    printf("Error: %s\n", strerror(errno));
    return 1;
  }

  fclose(f);
  return 0;
}

Note: errno is only set when something goes wrong, and it keeps its value until the next error. That is why you should only check it right after a function has failed (like when fopen() returns NULL).

Common Error Codes

Error constants are defined in <errno.h>. You can compare errno to them to detect specific issues:

#include <stdio.h>
#include <errno.h>

int main() {
  FILE *f = fopen("nothing.txt", "r");

  if (f == NULL) {
    if (errno == ENOENT) {
      printf("The file was not found.\n");
    } else {
      printf("Some other file error occurred.\n");
    }
    return 1;
  }

  fclose(f);
  return 0;
}

Using exit() to Stop the Program

If you want to stop the program immediately when an error occurs, you can use exit(). It lets you return a status code to the operating system.

Exit codes help signal whether the program finished successfully or with an error, like:

• 0 means success
• Non-zero values (like 1 or EXIT_FAILURE) indicate errors

#include <stdio.h>
#include <stdlib.h>

int main() {
  FILE *f = fopen("nothing.txt", "r");

  if (f == NULL) {
    printf("Failed to open file.\n");
    exit(1);
  }

  fclose(f);
  return 0;
}

Note: In main(), exit(1) does the same as return 1. The difference is that exit() stops the whole program from any function, while return only leaves the function it is in.

Common Exit Status Codes

#include <stdio.h>
#include <stdlib.h>

int main() {
  FILE *f = fopen("nothing.txt", "r");

  if (f == NULL) {
    perror("Could not open nothing.txt");
    exit(EXIT_FAILURE); // More readable than exit(1)
  }

  fclose(f);
  return EXIT_SUCCESS;
}

Summary

• Many C functions return NULL when something goes wrong
• Your own functions can return an error code (like -1) to tell the caller that something went wrong
• Use perror() to print a message about the error
• Use strerror(errno) to get the error message as a string
• errno stores the error code from the last failed action
• You can compare errno to values like ENOENT (file not found) or ENOMEM (not enough memory)
• Use exit() to stop the program early if there's an error