🚨 C++ Exception Handling – Catch & Manage Runtime Errors Gracefully

🧲 Introduction – Why Exception Handling Matters in C++

In modern C++ applications, handling unexpected situations—like file errors, memory issues, or invalid user inputs—is essential. Exception handling provides a structured way to manage errors at runtime without crashing the program.

🎯 In this guide, you’ll learn:

• What C++ exception handling is
• Syntax of try, throw, and catch
• How to use standard and custom exceptions
• Best practices for robust and maintainable error control

🔍 What Is Exception Handling in C++?

Exception handling is a mechanism that allows a program to detect and handle runtime errors dynamically by:

• Throwing an exception
• Catching it using a handler
• Executing a recovery or fallback path

💻 Code Examples – With Output

✅ Example 1: Basic try-catch Block

#include <iostream>
using namespace std;

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

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

🟢 Output:

Caught Exception: Division by zero error!

✅ Example 2: Using Standard Exception Classes

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

int main() {
    try {
        throw runtime_error("Something went wrong!");
    } catch (const runtime_error& e) {
        cout << "Runtime Error: " << e.what() << endl;
    }
}

🟢 Output:

Runtime Error: Something went wrong!

🧱 Syntax of Exception Handling

try {
    // Code that might throw
} catch (Type e) {
    // Handler
}

✅ Throwing Exceptions

throw value;              // Can be a primitive, string, or object
throw std::runtime_error("Error");

✅ Catching Multiple Types

catch (int e) { /* ... */ }
catch (const char* e) { /* ... */ }
catch (...) { /* Catch-all block */ }

🔧 Custom Exception Classes

You can create your own exceptions by inheriting from std::exception.

class MyException : public std::exception {
public:
    const char* what() const noexcept override {
        return "Custom exception occurred!";
    }
};

📘 Exception Types in Standard Library

💡 Best Practices & Tips

📘 Best Practice: Always throw objects (not primitive types) when possible—prefer std::exception derivatives.

💡 Tip: Catch exceptions by reference (catch (const std::exception& e)), not by value, to avoid slicing.

⚠️ Pitfall: Avoid throwing exceptions in destructors—it can lead to undefined behavior if another exception is active.

🛠️ Use Cases for Exception Handling

🔒 Secure Code: Prevent access violations or illegal memory operations
📁 File Handling: Handle read/write/open failures
🌐 Networking: Detect packet drops, timeouts, and disconnections
📊 Data Processing: Validate user inputs, formats, ranges
💡 Resource Management: Roll back transactions or free memory on failure

📌 Summary – Recap & Next Steps

🔍 Key Takeaways:

• C++ uses try, throw, and catch for exception handling
• Exceptions allow recovery from runtime errors without crashing
• Prefer std::exception hierarchy or custom class exceptions

⚙️ Real-World Relevance:
Exception handling is essential for building secure, crash-resistant applications, especially in finance, healthcare, robotics, or system-level code.

✅ Next Steps:

• Learn about C++ Signal Handling
• Explore how to manage OS-level signals like interrupts or segmentation faults

❓FAQ – C++ Exception Handling

❓Can I throw any data type in C++?
✅ Yes, but it’s best to throw objects (like std::exception) for better structure and information.

❓What happens if an exception is not caught?
⚠️ The program calls std::terminate() and aborts execution.

❓Is catch (...) good practice?
✅ It catches all exceptions but should be used sparingly, ideally for logging or fallback.

❓What’s the difference between throw and throws?
👉 C++ uses only throw; throws is a Java keyword.

❓Can I rethrow an exception?
✅ Yes. Use throw; inside a catch block to rethrow the current exception.