C++ - Try and Catch

Try and Catch in C++

Introduction

In C++, error handling is done using exceptions, which are special objects used to handle errors or unusual situations that may arise during the execution of a program. The try and catch blocks are used to handle exceptions. The try block contains code that might throw an exception, and the catch block is used to handle the exception.

Syntax of Try and Catch

The basic syntax of try and catch is as follows:

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

The try block contains the code that might generate an exception. If an exception occurs, the flow of execution jumps to the catch block, where you can handle the error appropriately.

Working with Exceptions

Exceptions are thrown using the throw keyword. Once an exception is thrown, the control jumps to the nearest matching catch block. If no matching catch block is found, the program terminates.

Code Example - Throw and Catch an Exception

#include 
#include 
using namespace std;

int divide(int a, int b) {
    if (b == 0) {
        throw runtime_error("Division by zero error!");
    }
    return a / b;
}

int main() {
    int x = 10, y = 0;
    try {
        cout << "Result: " << divide(x, y) << endl;
    } catch (const runtime_error& e) {
        cout << "Caught exception: " << e.what() << endl;
    }
    return 0;
}
    

In this example, the divide function checks if the divisor is zero. If it is, it throws a runtime_error exception, which is caught in the catch block in the main> function.

Multiple Catch Blocks

You can use multiple catch blocks to handle different types of exceptions. Each catch block can handle a different exception type or the same type with different exception parameters.

Code Example - Multiple Catch Blocks

#include 
#include 
using namespace std;

void checkValue(int value) {
    if (value < 0) {
        throw invalid_argument("Negative value not allowed!");
    }
    if (value == 0) {
        throw runtime_error("Zero value error!");
    }
    cout << "Value is: " << value << endl;
}

int main() {
    int num = -5;
    try {
        checkValue(num);
    } catch (const invalid_argument& e) {
        cout << "Caught exception: " << e.what() << endl;
    } catch (const runtime_error& e) {
        cout << "Caught exception: " << e.what() << endl;
    }
    return 0;
}
    

In this example, there are two catch blocks: one for handling invalid_argument exceptions and the other for handling runtime_error exceptions. The exception thrown will match the appropriate catch block.

Catch-All Block

In C++, you can use a "catch-all" block to catch any type of exception that is not specifically handled by previous catch blocks. This is done by using an ellipsis (catch(...)) as a catch block.

Code Example - Catch-All Block

#include 
#include 
using namespace std;

int main() {
    try {
        throw "This is a string exception!";
    } catch (const char* msg) {
        cout << "Caught exception: " << msg << endl;
    } catch (...) {
        cout << "Caught an unknown exception!" << endl;
    }
    return 0;
}
    

In this example, the catch(...) block catches any exceptions that are not specifically handled by other catch blocks.

Exception Propagation

If an exception is not caught in the current function, it is propagated (or "bubbled") up to the calling function. This process continues until the exception is caught or the program terminates.

Code Example - Exception Propagation

#include 
#include 
using namespace std;

void functionB() {
    throw runtime_error("Error in functionB");
}

void functionA() {
    functionB();  // Exception will be propagated
}

int main() {
    try {
        functionA();
    } catch (const runtime_error& e) {
        cout << "Caught exception: " << e.what() << endl;
    }
    return 0;
}
    

In this example, the exception thrown in functionB is propagated up to functionA and then caught in the main function.

Re-throwing Exceptions

In some cases, after catching an exception, you may want to re-throw it to allow it to be handled elsewhere. This can be done using the throw keyword inside the catch block.

Code Example - Re-throwing an Exception

#include 
#include 
using namespace std;

void functionA() {
    try {
        throw runtime_error("Error in functionA");
    } catch (const runtime_error& e) {
        cout << "Caught exception in functionA: " << e.what() << endl;
        throw;  // Re-throw the exception
    }
}

int main() {
    try {
        functionA();
    } catch (const runtime_error& e) {
        cout << "Caught exception in main: " << e.what() << endl;
    }
    return 0;
}
    

In this example, after catching the exception in functionA, it is re-thrown and caught in the main function.

The try and catch mechanism in C++ provides a powerful way to handle runtime errors and exceptions in a controlled manner. By using exceptions, you can ensure that your program can handle unexpected situations gracefully without crashing. Understanding how to throw, catch, and propagate exceptions will help you build more robust and error-resistant programs.