Exception handling in C++

Exception handling in C++ is a powerful mechanism that allows us to deal with exceptional conditions or errors in our code in a structured and efficient manner. It provides a way to separate the normal flow of our program from error-handling logic. Exception handling is an essential feature for writing robust and reliable software. In C++, exception handling is done through try, throw, and catch keywords.

The Basics of Exception Handling:

1. 1. Try: In C++, we define a try block to enclose the code that may potentially throw an exception. This block is used to identify the region where an exception can be thrown.

2. 2. Throw: When an exceptional situation occurs within the try block, we can use the throw keyword to raise an exception. We can throw any object as an exception, but it is often best to use objects of classes derived from the standard library's std::exception class.

3. 3. Catch: We use a catch block to specify the type of exception we want to catch and how to handle it. Multiple catch blocks can be used to catch different types of exceptions. Once an exception is caught, the corresponding catch block is executed.

Example 1: Basic Exception Handling

cpp
#include <iostream>
using namespace std;
int main() {
    try {
        int num = 10;
        if (num > 5) {
            throw "Number is greater than 5";
        }
    } catch (const char* message) {
        cerr << "Exception caught: " << message << endl;
    }

    return 0;
}

In this example, we use a try block to catch an exception (a C-style string) thrown when num is greater than 5. The catch block handles the exception and prints an error message.

Example 2: Multiple Catch Blocks

cpp
#include <iostream>
#include <stdexcept>
using namespace std;
int main() {
    try {
        int num = 10;
        if (num > 5) {
            throw runtime_error("Number is greater than 5");
        }
    } catch (const char* message) {
        cerr << "Caught a char* exception: " << message << endl;
    } catch (const exception& e) {
        cerr << "Caught an exception: " << e.what() << endl;
    }

    return 0;
}

Here, we throw an exception of type std::runtime_error and catch it with two different catch blocks—one for const char* and one for std::exception. The latter is a more general catch block that can catch any exception derived from std::exception.

Example 3: Exception Propagation

cpp
#include <iostream>
#include <stdexcept>
using namespace std;
void someFunction() {
    try {
        throw runtime_error("An error occurred.");
    } catch (const exception& e) {
        cerr << "Exception caught in someFunction: " << e.what() << endl;
        throw;  // Re-throw the same exception
    }
}

int main() {
    try {
        someFunction();
    } catch (const exception& e) {
        cerr << "Exception caught in main: " << e.what() << endl;
    }

    return 0;
}

In this example, the someFunction throws an exception, and the main function catches and re-throws it. This allows us to propagate exceptions up the call stack to be handled at an appropriate level.