Handling Errors with C++

This chapter will focus on error handling in C++. As a programmer, you will inevitably encounter situations where you need to determine the best approach to propagate program errors. Whether you use error codes or exceptions, we will delve into them to gain a better understanding of how to use them effectively.

In this chapter, we will examine how to handle errors reported by POSIX APIs using C++. We will begin by covering the errno thread-local variable and the strerror function. After that, we will introduce std::error_code and std::error_condition and demonstrate how they help to wrap POSIX errors that come from POSIX APIs. We will also investigate custom error categories, which allow us to compare errors produced by various sources and develop platform-independent error-handling code.

As we progress, we will learn about exceptions in C++ and how to convert std::error_code into a std::system_error exception. We will also explore some best practices...

Technical requirements

All examples in this chapter have been tested in an environment with the following configuration:

• Linux Mint 21 Cinnamon edition
• GCC 12.2 with compiler flags:
  • -std=c++20
• A stable internet connection
• Please make sure your environment is at least that recent. For all the examples, you can alternatively use https://godbolt.org/.
• All code examples in this chapter are available for download from https://github.com/PacktPublishing/C-Programming-for-Linux-Systems/tree/main/Chapter%205.

Handling errors from POSIX APIs with C++

In POSIX-compliant systems, such as Unix and Linux, error handling is based on the use of error codes and error messages to communicate errors between functions and applications.

In general, when a function encounters an error, it returns a non-zero error code and sets the errno global variable to a specific error value that indicates the nature of the error. The application can then use the errno variable to determine the cause of the error and take appropriate action.

In addition to error codes, POSIX-compliant functions often provide error messages that describe the nature of the error in more detail. These error messages are typically accessed using the strerror function, which takes an error code as input and returns a pointer to a sequence of characters terminated with a null character containing the corresponding error message.

The POSIX error-handling style requires developers to check for errors after each system call or function...

From error codes to exceptions

Exception handling is an important aspect of programming, especially when dealing with errors that can disrupt the normal flow of a program. While there are several ways to handle errors in a code base, exceptions provide a powerful mechanism for handling errors in a way that separates error flow from normal program flow.

When working with error codes, it can be challenging to ensure that all error cases are properly handled and that the code remains maintainable. By wrapping error codes in exceptions, we can create a more pragmatic approach to error handling that makes it easier to reason about code and catch errors in a more centralized manner.

It’s hard to say which approach is better when dealing with error handling in a code base, and the decision to use exceptions should be based on pragmatic considerations. While exceptions can provide significant benefits in terms of code organization and maintainability, they may come with a performance...

Summary

This chapter has covered various techniques for error handling when working with POSIX APIs in C++. We discussed the use of errno, a thread-local variable, and the strerror function. We also explored how std::error_code and std::error_condition can wrap POSIX errors and how custom error categories enable us to compare errors generated by different sources and develop platform-independent error-handling code. Furthermore, we delved into exceptions in C++ and how to convert std::error_code into an exception of the std::system_error type.

We also examined best practices for working with exceptions, such as throwing them by value and catching them by reference, to avoid issues such as object slicing. Finally, we learned about the RAII technique in C++, which eliminates the need for a finally construct in the language.

In the next chapter, we will explore the topic of concurrency with C++.