Exception Handling in C++

What is Exception Handling?

Exception handling is a method of responding to runtime errors without crashing the program. It allows you to:

• Detect errors (exceptions).
• Handle them gracefully.
• Continue program execution or terminate safely.

Key Concepts of Exception Handling

• Exception: An unexpected event or error during program execution.
• Throwing an Exception: Generating an exception using the throw keyword.
• Catching an Exception: Handling an exception using the catch block.
• Try Block: A block of code that is monitored for exceptions.
• Catch Block: A block of code that handles the exception.

Basic Syntax:

try {
    // Code that may cause an exception
    throw exception;
}
catch (exception_type identifier) {
    // Code to handle the exception
}

Why Use Exception Handling?

• It allows for cleaner code without excessive error-checking logic.
• It separates error detection from error handling.
• It provides graceful error recovery.

Basic Example of Exception Handling

#include <iostream>
using namespace std;

int main() {
    try {
        int a = 10, b = 0;
        if (b == 0) {
            throw "Division by zero error!";
        }
        cout << "Result: " << a / b << endl;
    }
    catch (const char* e) {
        cout << "Exception caught: " << e << endl;
    }

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

Output:

Exception caught: Division by zero error!
Program continues after exception.

Explanation:

• The throw keyword generates an exception (a string message).
• The catch block catches the exception and handles it.
• The program continues normally after the exception is handled.

Throwing Exceptions

• You can throw any data type (int, double, string, object).
• You can use throw without any expression to rethrow an exception.

Examples:

#include <iostream>
using namespace std;

void checkNumber(int num) {
    if (num < 0)
        throw num;          // Throwing an int
    if (num == 0)
        throw "Zero is not allowed."; // Throwing a const char*
}

int main() {
    try {
        checkNumber(-5);
    }
    catch (int e) {
        cout << "Exception: Negative number - " << e << endl;
    }
    catch (const char* e) {
        cout << "Exception: " << e << endl;
    }

    return 0;
}

Output:

Exception: Negative number - -5

Catching Multiple Exceptions

You can use multiple catch blocks to handle different types of exceptions.

Example:

#include <iostream>
using namespace std;

int main() {
    try {
        int choice;
        cout << "Enter 1 for int exception, 2 for double: ";
        cin >> choice;

        if (choice == 1)
            throw 404;
        else if (choice == 2)
            throw 3.14;
        else
            throw "Invalid choice.";
    }
    catch (int e) {
        cout << "Integer Exception Caught: " << e << endl;
    }
    catch (double e) {
        cout << "Double Exception Caught: " << e << endl;
    }
    catch (...) {  // Catches any other type
        cout << "General Exception Caught." << endl;
    }

    return 0;
}

Output:

Enter 1 for int exception, 2 for double: 1
Integer Exception Caught: 404

Exception Handling with Functions

Exceptions can also be thrown from functions and caught in the calling function.

Example:

#include <iostream>
using namespace std;

void divide(int a, int b) {
    if (b == 0)
        throw "Division by zero!";
    cout << "Result: " << a / b << endl;
}

int main() {
    try {
        divide(10, 0);
    }
    catch (const char* e) {
        cout << "Exception: " << e << endl;
    }
    return 0;
}

Output:

Exception: Division by zero!

Nested Try-Catch Blocks

You can nest try-catch blocks to handle exceptions at different levels.

Example:

#include <iostream>
using namespace std;

int main() {
    try {
        try {
            throw "Inner exception!";
        }
        catch (const char* e) {
            cout << "Caught in inner catch: " << e << endl;
            throw; // Rethrowing exception
        }
    }
    catch (const char* e) {
        cout << "Caught in outer catch: " << e << endl;
    }
    return 0;
}

Output:

Caught in inner catch: Inner exception!
Caught in outer catch: Inner exception!

Explanation:

• The inner catch block rethrows the exception using throw.
• The outer catch block catches it again.

Exception Handling in Classes (Custom Exceptions)

You can create custom exception classes for better control.

Example:

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

// Custom exception class
class InvalidAgeException {
private:
    string message;
public:
    InvalidAgeException(string msg) : message(msg) {}
    string getMessage() const {
        return message;
    }
};

// Function using custom exception
void checkAge(int age) {
    if (age < 0)
        throw InvalidAgeException("Age cannot be negative.");
    cout << "Your age is: " << age << endl;
}

int main() {
    try {
        checkAge(-5);
    }
    catch (InvalidAgeException &e) {
        cout << "Exception: " << e.getMessage() << endl;
    }

    return 0;
}

Output:

Exception: Age cannot be negative.

Standard Exception Classes (std::exception)

C++ provides a set of standard exception classes in the <exception> header:

• std::exception (Base class)
• std::runtime_error
• std::logic_error
• std::out_of_range
• std::bad_alloc (for memory allocation errors)

Example:

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

int main() {
    try {
        int *arr = new int[100000000000]; // Large memory allocation
    }
    catch (bad_alloc &e) {
        cout << "Memory Allocation Error: " << e.what() << endl;
    }
    return 0;
}

Output:

Memory Allocation Error: std::bad_alloc

Best Practices for Exception Handling

1. Use exceptions only for exceptional conditions (not for normal flow).
2. Catch exceptions by reference (catch (const ExceptionType& e)).
3. Use custom exception classes for complex applications.
4. Prefer standard exceptions for common scenarios.
5. Always use a catch(...) block for unknown exceptions.

Summary

In this tutorial, you learned:

• What exception handling is and why it is important.
• How to use try, catch, and throw for exception handling.
• How to handle multiple exceptions.
• Custom exception classes for more flexibility.
• Advanced concepts like nested try-catch and standard exceptions.