A Complete Guide - CPP Programming Try, Catch, and Throw Keywords

Understanding try, catch, and throw in C++

• try block: This is where you place the code that might throw an exception.
• catch block: This is where you handle the exception thrown from the try block.
• throw keyword: This is used to throw an exception, which can then be caught by a catch block.

Step-by-Step Example

Step 1: Basic Structure

Let's start with a very simple example that includes all three components (try, catch, and throw).

#include <iostream>
using namespace std;

int main() {
    try {
        int x = -1;
        if (x < 0) {
            throw x; // Throwing an integer exception
        }
        cout << "x is a positive number." << endl;
    }
    catch (int e) {
        cout << "Caught an integer exception: " << e << endl;
    }

    return 0;
}

Explanation:

• The try block contains a conditional statement to check if x is negative.
• If x is negative, throw x; is executed, which throws an integer.
• The catch block catches the integer exception and prints a message.

Step 2: Throwing String Exceptions

You can also throw and catch exceptions of type std::string or other types.

#include <iostream>
using namespace std;

int main() {
    try {
        string message = "Error: Negative value detected.";
        int x = -1;
        if (x < 0) {
            throw message; // Throwing a string exception
        }
        cout << "x is a positive number." << endl;
    }
    catch (string &e) {
        cout << "Caught a string exception: " << e << endl;
    }

    return 0;
}

Explanation:

• The try block throws a string exception if x is negative.
• The catch block catches the string exception and prints it.

Step 3: Using Custom Exception Classes

For more complex error handling, you can define your own exception classes.

#include <iostream>
using namespace std;

// Custom exception class
class MyException : public exception {
public:
    virtual const char* what() const throw() {
        return "Negative value detected!";
    }
};

int main() {
    try {
        int x = -1;
        if (x < 0) {
            throw MyException(); // Throwing a custom exception
        }
        cout << "x is a positive number." << endl;
    }
    catch (MyException& e) {
        cout << "Caught an exception: " << e.what() << endl;
    }

    return 0;
}

Explanation:

• We define a custom exception class MyException derived from std::exception.
• The what() method is overridden to return a custom error message.
• In the try block, throw MyException(); is used to throw an instance of our custom exception.
• The catch block catches our custom exception and prints its message using e.what().

Step 4: Multiple Catch Blocks

You can also handle multiple types of exceptions using multiple catch blocks.

#include <iostream>
using namespace std;

// Custom exception class
class MyException : public exception {
public:
    virtual const char* what() const throw() {
        return "Negative value detected!";
    }
};

int main() {
    try {
        int x = -1;
        if (x < 0) {
            if (x == -1) {
                throw -1; // Throwing an integer exception
            }
            throw MyException(); // Throwing a custom exception
        }
        cout << "x is a positive number." << endl;
    }
    catch (int e) {
        cout << "Caught an integer exception: " << e << endl;
    }
    catch (MyException& e) {
        cout << "Caught a custom exception: " << e.what() << endl;
    }

    return 0;
}

Explanation:

• We throw different types of exceptions based on the value of x.
• We use multiple catch blocks to handle different types of exceptions separately.

Summary

• Use try blocks to enclose code that might throw exceptions.
• Use catch blocks to handle exceptions by catching them and performing appropriate actions.
• Use throw to throw exceptions, which can be of any data type, including custom exception classes.
• You can have multiple catch blocks to handle different types of exceptions.