Standard Exceptions Explained

Standard exceptions in C++ are predefined exceptions that are part of the C++ Standard Library. These exceptions provide a way to handle common error conditions in a consistent manner. Understanding standard exceptions is crucial for writing robust and maintainable code. This section will cover the key concepts related to standard exceptions in C++.

Key Concepts

1. Exception Hierarchy

The standard exceptions in C++ are organized in a hierarchy, with std::exception as the base class. This hierarchy allows for a structured approach to handling exceptions, as more specific exceptions can be caught and handled appropriately.

Example:

#include <iostream>
#include <stdexcept>

int main() {
    try {
        throw std::runtime_error("A runtime error occurred");
    } catch (const std::exception& e) {
        std::cerr << "Caught exception: " << e.what() << std::endl;
    }
    return 0;
}
    

2. Common Standard Exceptions

Some of the commonly used standard exceptions include:

• std::logic_error: Represents errors in the internal logic of the program, such as invalid arguments.
• std::runtime_error: Represents errors that can only be detected during runtime, such as division by zero.
• std::out_of_range: Represents errors where an index is out of the valid range.
• std::invalid_argument: Represents errors where an invalid argument is passed to a function.

Example:

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

int main() {
    std::vector<int> vec = {1, 2, 3};
    try {
        int value = vec.at(10); // This will throw std::out_of_range
    } catch (const std::out_of_range& e) {
        std::cerr << "Caught exception: " << e.what() << std::endl;
    }
    return 0;
}
    

3. Custom Exceptions

You can create custom exceptions by deriving from std::exception or one of its derived classes. This allows you to define exceptions that are specific to your application's needs.

Example:

#include <iostream>
#include <stdexcept>

class MyException : public std::exception {
public:
    const char* what() const noexcept override {
        return "My custom exception occurred";
    }
};

int main() {
    try {
        throw MyException();
    } catch (const std::exception& e) {
        std::cerr << "Caught exception: " << e.what() << std::endl;
    }
    return 0;
}
    

4. Exception Safety

Exception safety refers to the ability of a program to handle exceptions in a way that ensures the program remains in a consistent state. There are different levels of exception safety, such as basic guarantee, strong guarantee, and no-throw guarantee.

Example:

#include <iostream>
#include <stdexcept>

void safeFunction() {
    std::vector<int> vec = {1, 2, 3};
    try {
        vec.at(10) = 42; // This will throw std::out_of_range
    } catch (const std::out_of_range& e) {
        std::cerr << "Caught exception: " << e.what() << std::endl;
        // Ensure the program remains in a consistent state
    }
}

int main() {
    safeFunction();
    return 0;
}
    

Examples and Analogies

Example: Handling Multiple Exceptions

#include <iostream>
#include <stdexcept>

int main() {
    try {
        throw std::invalid_argument("Invalid argument");
    } catch (const std::invalid_argument& e) {
        std::cerr << "Caught invalid_argument: " << e.what() << std::endl;
    } catch (const std::exception& e) {
        std::cerr << "Caught exception: " << e.what() << std::endl;
    }
    return 0;
}
    

Analogy: Standard Exceptions as Traffic Signs

Think of standard exceptions as traffic signs that guide the flow of your program. Just as traffic signs indicate potential hazards and guide drivers to safe routes, standard exceptions help you identify and handle errors in your code. By understanding these signs, you can navigate your program more safely and efficiently.

Conclusion

Standard exceptions in C++ provide a robust and consistent way to handle common error conditions. By understanding the exception hierarchy, common standard exceptions, custom exceptions, and exception safety, you can write more reliable and maintainable code. Standard exceptions are a key tool in the C++ programmer's toolkit, enabling you to handle errors gracefully and ensure your program remains in a consistent state.