Chapter 16: Exception Handling

Exception Handling in C++: Making Your Code Robust & Reliable

Hello my wonderful student! 🌟 Welcome to Lesson 16 — Exception Handling — one of the most important topics for writing production-quality C++ code!

Exceptions are C++’s way of saying: “Something went wrong (file not found, division by zero, out of memory, invalid input…), and I’m going to throw the problem up the call stack until someone catches it and handles it properly.”

Think of exceptions like a fire alarm:

• When a problem occurs → the alarm goes off (throw)
• Someone (the nearest handler) hears it and takes action (catch)
• If no one handles it → the program terminates (like calling emergency services)

Today we’ll cover everything in great detail:

• try, catch, throw
• Multiple catch blocks & catch-all
• Custom exceptions (your own error classes)
• noexcept specifier (modern C++ safety & performance)

Let’s go step-by-step with real-life analogies and complete examples!

1. Basic try-catch-throw – The Core Mechanism

Syntax:

Important rules:

• Code inside try is normal code
• When an exception is thrown → execution jumps to the matching catch
• If no catch matches → program calls std::terminate() (crashes)

Simple example – Division by zero

Output:

• divide(10, 0) → throws std::runtime_error
• Control jumps to catch block → prints error message
• Program does NOT crash — it continues normally

2. Catching Multiple Exception Types

Best practice:

• Catch specific exceptions first
• Catch base classes (like std::exception) last if needed
• Use catch by reference (&) → avoids copying

3. Custom Exceptions – Your Own Error Types

You can (and should!) create your own exception classes — it makes error handling much clearer.

Example – Custom exception hierarchy

Output (for negative amount):

Why custom exceptions?

• Clearer error messages
• Specific handling for different problems
• Easy to catch groups of related errors

4. noexcept Specifier – Modern C++ Safety & Performance

noexcept tells the compiler: “This function promises never to throw an exception. If it does → call std::terminate() immediately.”

Why use it?

• Performance (compiler can optimize better)
• Safety (document that exceptions are not expected)
• Move semantics (required for some STL containers)

Examples:

Best practice (2025+):

• Mark destructors, move constructors, move assignment operators as noexcept
• Use noexcept on small, performance-critical functions that really don’t throw

5. Full Practical Example – File Reading with Exception Handling

Tip: Always catch std::exception& as a fallback — it catches most standard exceptions.

Your Mini Homework (Try These!)

1. Write a function safeDivide(double a, double b) that throws a custom DivisionByZeroException if b == 0.
2. Create a SafeArray class that throws IndexOutOfRangeException when accessing invalid indices.
3. Write a function marked noexcept that allocates memory — explain what happens if new throws.

You’re doing absolutely incredible! Exception handling is what separates toy programs from real, reliable software — you’ve just mastered one of the most critical topics!

Next lesson: File I/O & Streams — reading/writing files, binary data, serialization — super useful for real apps!

Any questions? Confused about custom exceptions or noexcept? Want more examples with stack unwinding or multiple catch blocks? Just ask — your friendly C++ teacher is right here for you! 🚀