Exception Hierarchy in C++: What It Is and How It Works

In C++, the exception hierarchy is a structured set of classes that represent different types of errors, all derived from the base class std::exception. This hierarchy allows programmers to catch errors at different levels of detail, from general exceptions to specific error types.

How It Works

Think of the exception hierarchy in C++ like a family tree of error types. At the top, you have the most general error class, std::exception. This is like the parent that covers all kinds of exceptions. Below it, there are more specific child classes like std::runtime_error and std::logic_error, which represent different categories of problems.

This structure helps your program decide how to handle errors. If you want to catch any error, you catch the parent std::exception. But if you want to handle a specific problem, like a logic mistake or a runtime failure, you catch the child class. This way, your program can respond appropriately depending on the error type.

Example

This example shows how to catch exceptions using the hierarchy. We throw a std::out_of_range exception, which is a child of std::logic_error, which in turn is a child of std::exception. The catch blocks show how more specific exceptions are caught before general ones.

cpp

#include <iostream>
#include <exception>
#include <stdexcept>

int main() {
    try {
        throw std::out_of_range("Index out of range");
    } catch (const std::out_of_range& e) {
        std::cout << "Caught out_of_range: " << e.what() << '\n';
    } catch (const std::logic_error& e) {
        std::cout << "Caught logic_error: " << e.what() << '\n';
    } catch (const std::exception& e) {
        std::cout << "Caught exception: " << e.what() << '\n';
    }
    return 0;
}

Output

Caught out_of_range: Index out of range

When to Use

Use the exception hierarchy in C++ when you want to handle errors cleanly and clearly. If your program can face different kinds of problems, catching specific exceptions lets you fix or report them properly. For example, you might want to handle file errors differently from logic errors.

In real-world programs, this helps keep your code organized and makes debugging easier. You can catch broad exceptions to log errors and catch specific ones to recover or give user-friendly messages.

Key Points

• std::exception is the base class for all standard exceptions.
• Derived classes like std::runtime_error and std::logic_error represent specific error types.
• Catch exceptions from most specific to most general to handle errors properly.
• Using the hierarchy helps write clearer and more maintainable error handling code.

Key Takeaways

The exception hierarchy organizes error types from general to specific in C++.

Always catch exceptions from the most specific class to the most general one.

Use derived exception classes to handle different error situations clearly.

std::exception is the base class for all standard exceptions in C++.