exception

Header: : <exception>

The <exception> header is a fundamental part of the C++ Standard Library that provides support for exception handling. It defines the base class for all exceptions (std::exception) and several standard exception classes derived from it. This header is crucial for implementing robust error handling mechanisms in C++ programs, allowing for the separation of error detection and error handling code.

Key Characteristics

• Defines the base std::exception class
• Provides several standard exception classes (e.g., std::runtime_error, std::logic_error)
• Includes functions for exception handling (std::terminate, std::set_terminate)
• Offers the std::nested_exception class for handling nested exceptions
• Supports the creation of custom exception classes
• Enables the use of try-catch blocks for structured exception handling

Example 1: Basic Exception Handling

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

double divide(double numerator, double denominator) {
    if (denominator == 0) {
        throw std::runtime_error("Division by zero!");
    }
    return numerator / denominator;
}

int main() {
    try {
        std::cout << "Result: " << divide(10, 2) << std::endl;
        std::cout << "Result: " << divide(10, 0) << std::endl;
    } catch (const std::exception& e) {
        std::cerr << "Caught exception: " << e.what() << std::endl;
    }

    return 0;
}

Explanation:

• We define a divide function that throws a std::runtime_error for division by zero.
• The try block contains the code that might throw an exception.
• The catch block catches any exception derived from std::exception.
• e.what() returns a C-style string describing the exception.

Example 2: Custom Exception Class

#include <exception>
#include <string>
#include <iostream>

class CustomException : public std::exception {
private:
    std::string message;

public:
    explicit CustomException(const std::string& msg) : message(msg) {}

    const char* what() const noexcept override {
        return message.c_str();
    }
};

void riskyFunction(int value) {
    if (value < 0) {
        throw CustomException("Negative value not allowed");
    }
    std::cout << "Processing value: " << value << std::endl;
}

int main() {
    try {
        riskyFunction(5);
        riskyFunction(-1);
    } catch (const CustomException& e) {
        std::cerr << "Custom exception caught: " << e.what() << std::endl;
    } catch (const std::exception& e) {
        std::cerr << "Standard exception caught: " << e.what() << std::endl;
    }

    return 0;
}

Explanation:

• We define a CustomException class derived from std::exception.
• The what() function is overridden to return a custom error message.
• riskyFunction throws our custom exception for negative values.
• The try block contains calls that might throw exceptions.
• We use multiple catch blocks to handle different types of exceptions.

Example 3: Nested Exceptions

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

void innerFunction() {
    throw std::runtime_error("Inner error");
}

void outerFunction() {
    try {
        innerFunction();
    } catch (const std::exception& e) {
        std::throw_with_nested(std::runtime_error("Outer error"));
    }
}

void printException(const std::exception& e, int level = 0) {
    std::cerr << std::string(level, ' ') << "Exception: " << e.what() << std::endl;
    try {
        std::rethrow_if_nested(e);
    } catch (const std::exception& nested) {
        printException(nested, level + 1);
    }
}

int main() {
    try {
        outerFunction();
    } catch (const std::exception& e) {
        std::cout << "Caught exception. Hierarchy:" << std::endl;
        printException(e);
    }

    return 0;
}

Explanation:

• std::throw_with_nested is used to throw an exception while preserving the current exception.
• std::rethrow_if_nested checks if an exception is nested and rethrows it if so.
• We define a recursive printException function to display the hierarchy of nested exceptions.
• This example demonstrates how to handle and inspect nested exceptions.

Example 4: Exception Handling with Standard Exceptions

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

void demonstrateExceptions() {
    std::vector<int> vec(5);

    try {
        // Demonstrate out_of_range
        std::cout << vec.at(10) << std::endl;
    } catch (const std::out_of_range& e) {
        std::cerr << "Out of range error: " << e.what() << std::endl;
    }

    try {
        // Demonstrate bad_alloc
        std::vector<int> hugeVector(std::vector<int>::max_size());
    } catch (const std::bad_alloc& e) {
        std::cerr << "Bad allocation error: " << e.what() << std::endl;
    }

    try {
        // Demonstrate invalid_argument
        std::stoi("not a number");
    } catch (const std::invalid_argument& e) {
        std::cerr << "Invalid argument error: " << e.what() << std::endl;
    }
}

int main() {
    try {
        demonstrateExceptions();
    } catch (const std::exception& e) {
        std::cerr << "Caught unhandled exception: " << e.what() << std::endl;
    }

    return 0;
}

Explanation:

• We demonstrate several standard exception types: std::out_of_range, std::bad_alloc, and std::invalid_argument.
• Each exception is caught and handled separately within demonstrateExceptions.
• The main function has a catch-all handler for any unhandled std::exception.

Additional Considerations

1. Exception Safety: Ensure resources are properly managed when exceptions occur (e.g., using RAII).

2. Performance: Exception handling can have a performance cost, especially in tight loops.

3. Noexcept Specifier: Use noexcept for functions that don't throw exceptions to enable compiler optimizations.

4. Exception Specifications: Modern C++ discourages the use of dynamic exception specifications.

5. Catch by Reference: Always catch exceptions by reference to avoid slicing.

Summary

The <exception> header in C++ provides essential tools for exception handling:

• It defines the base std::exception class and several derived standard exceptions.
• Enables the creation of custom exception classes.
• Supports nested exceptions for complex error scenarios.
• Facilitates structured exception handling with try-catch blocks.
• Offers utilities like std::terminate and std::set_terminate for managing program termination due to unhandled exceptions.

Exception handling is a powerful mechanism for managing errors and exceptional conditions in C++ programs. It allows for the separation of error detection and error handling code, leading to cleaner and more robust software. By using the facilities provided by <exception>, developers can create more resilient applications that gracefully handle unexpected situations and provide meaningful error information to users or logging systems.

When using exceptions, it's important to consider exception safety, performance implications, and to design exception hierarchies that make sense for your application's error handling needs. Proper use of exceptions can significantly improve the reliability and maintainability of C++ code.

Related

• What are the main functions provided by the include file
• How does the include file enhance error handling in C++
• What are the common exceptions handled by the library
• How can the include file be used to customize exception handling
• What are the differences between and in C++