Exception Handling in C++

# CHAPTER 21

Exception Handling #

1. Introduction #

2. Learning Objectives #

• Understand the try, throw, and catch keywords.

• Catch multiple types of exceptions.

• Understand the "catch-all" handler catch(...).

• Create Custom Exception classes.

• Ensure Exception Safety.

3. The Big Three: Try, Throw, Catch #

• try: A block of code that you suspect might cause an error.

• throw: Used to manually trigger an error when a problem is detected.

• catch: A block of code that handles the error if one is thrown.

#include <iostream>
using namespace std;

int main() {
    int denominator = 0;
    int numerator = 10;
    
    try {
        if (denominator == 0) {
            // 1. Detect the error and THROW it
            throw "Error: Division by zero!"; 
        }
        // If thrown, this line is SKIPPED
        cout << (numerator / denominator) << endl; 
        
    } catch (const char* msg) { 
        // 2. CATCH the error and handle it gracefully
        cout << msg << endl;
    }
    
    cout << "Program continues running..." << endl;
    return 0;
}

*Output:*

Error: Division by zero!
Program continues running...

4. Catching Multiple Exceptions #

try {
    int age = -5;
    if (age < 0) throw 404; // Throw an int
    if (age > 120) throw "Invalid age"; // Throw a string
} catch (int errorNum) {
    cout << "Error Code: " << errorNum << endl;
} catch (const char* errorMsg) {
    cout << "Error: " << errorMsg << endl;
}

5. The Catch-All Handler #

try {
    throw 5.5; // Throws a double
} catch (...) { // Catches EVERYTHING
    cout << "An unknown error occurred!" << endl;
}

6. Standard Exceptions (std::exception) #

#include <iostream>
#include <stdexcept> // Required for standard exceptions
using namespace std;

int main() {
    try {
        throw runtime_error("Database connection failed!");
    } catch (const exception& e) { // Catching by reference is Best Practice!
        cout << "System Error: " << e.what() << endl; // what() prints the message
    }
    return 0;
}

7. Custom Exceptions #

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

class OverheatingException : public exception {
  public:
    // Override the what() method
    const char* what() const throw() {
        return "CRITICAL: Engine temperature exceeded safe limits!";
    }
};

int main() {
    try {
        throw OverheatingException();
    } catch (const OverheatingException& e) {
        cout << e.what() << endl;
    }
    return 0;
}

8. Mini Project: Safe Calculator #

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

double divide(double a, double b) {
    if (b == 0) {
        throw invalid_argument("Division by zero is mathematically undefined.");
    }
    return a / b;
}

int main() {
    double num1, num2;
    cout << "Enter two numbers to divide: ";
    cin >> num1 >> num2;
    
    try {
        double result = divide(num1, num2);
        cout << "Result: " << result << endl;
    } catch (const invalid_argument& e) {
        cout << "CALCULATOR ERROR: " << e.what() << endl;
    }
    
    return 0;
}

9. Memory-Level Explanation #

10. Common Mistakes #

• Memory Leaks during Stack Unwinding: If you allocate memory with new, and an exception is thrown *before* you call delete, that memory is leaked. (This is why Smart Pointers are used in Modern C++!).

• Catching by Value instead of Reference: catch(exception e) creates a copy of the exception object, which is slow and can cause "object slicing". Always use catch(const exception& e).

11. Exercises #

1. 1. Write a program that asks for a user's age. If the age is negative, throw an invalidargument exception.

1. 2. Create an array of size 5. Ask the user for an index to access. If the index is > 4, throw an outof_range exception.

12. MCQ Quiz with Answers #

13. Interview Questions #

• Q: Explain Stack Unwinding in the context of C++ Exceptions.

• Q: Why should you catch exceptions by const reference?

• Q: Explain the noexcept specifier in Modern C++. (Answer: It tells the compiler that a function will *never* throw an exception, allowing the compiler to optimize the code heavily).

14. Summary #

15. Next Chapter Recommendation #