Welcome to C++ Programming Tutorial

Exception Handling in C++

Exception handling in C++ is a mechanism for responding to runtime errors, allowing the program to deal with unexpected situations gracefully. C++ uses three keywords for exception handling: try, catch, and throw.

Key Concepts:

• try block: This block contains the code that may generate an exception. If an exception occurs, the code inside the try block is skipped, and the control is transferred to the appropriate catch block.

try {
    // Code that may throw an exception
}

Copy
• throw statement: When an error occurs within the try block, an exception is thrown using the throw keyword. The type of the exception determines which catch block will handle it.

throw exception; // Exception can be of any data type

Copy
• catch block: This block handles the exception thrown by the try block. The catch block is defined with a parameter that matches the type of the exception.

catch (exception_type e) {
    // Code to handle the exception
}

Copy

Example of Exception Handling:

#include <iostream>
using namespace std;

int main() {
    int numerator, denominator;
    cout << "Enter numerator: ";
    cin << numerator;
    cout << "Enter denominator: ";
    cin << denominator;

    try {
        if (denominator == 0)
            throw "Division by zero error!";

        cout << "Result: " << numerator / denominator << endl;
    } catch (const char* e) {
        cout << "Exception caught: " << e << endl;
    }

    cout << "Program continues..." << endl;
    return 0;
}

Output:

Enter numerator: 10
Enter denominator: 0
Exception caught: Division by zero error!
Program continues...

Explanation:

• The try block contains code that could potentially cause a division by zero error.
• If the denominator is zero, the throw statement is executed, throwing an exception of type const char*.
• The catch block catches the exception and handles it by displaying an error message.
• After the exception is handled, the program continues to execute the remaining code.

Custom Exception Classes:

You can create your own exception classes by inheriting from the std::exception class.

#include <iostream>
#include <exception>
using namespace std;

class MyException : public exception {
public:
    const char* what() const throw() {
        return "Custom Exception occurred";
    }
};

int main() {
    try {
        throw MyException();
    } catch (MyException& e) {
        cout << e.what() << endl;
    }

    return 0;
}

Output:

Custom Exception occurred

Important Points:

• Multiple catch blocks: You can have multiple catch blocks to handle different types of exceptions.
• Catch all exceptions: Use catch(...) to catch all types of exceptions.
• Re-throwing exceptions: You can re-throw an exception using the throw keyword inside a catch block.
• Nested try-catch blocks: C++ allows nested try-catch blocks for finer control over exception handling.