Exception Handling

Introduction

In the previous lesson, you learned about namespaces. Now consider a program that asks the user to enter two numbers and performs a calculation.

Suppose the user enters 20 as the numerator and 0 as the denominator. The program attempts to perform integer division by zero, which is an invalid operation and results in undefined behavior.

int numerator = 20;
int denominator = 0;

int result =
    numerator / denominator;

Programs can also encounter many other exceptional situations, such as invalid input, unavailable files, failed network operations, or insufficient resources.

What is Exception Handling?

Exception handling is a mechanism for reporting and handling exceptional situations that occur while a program is running.

Instead of mixing every possible error response directly into normal program logic, C++ allows code to throw an exception and transfer control to a matching handler.

Normal Code
    │
    ▼
Exceptional Condition
    │
    ▼
Throw Exception
    │
    ▼
Find Matching Handler
    │
    ▼
Handle Situation

Why Do We Need Exception Handling?

Real applications interact with users, files, networks, databases, memory, devices, and external systems. Many operations can fail for reasons that are not part of the normal successful path.

Real-World Analogy

Imagine using an ATM. You insert your card and enter a PIN.

If the PIN is correct, the ATM continues with the transaction. If the PIN is incorrect, the machine does not simply shut down. It detects the problem and follows an alternative error-handling path.

          ATM Transaction
                 │
                 ▼
             Enter PIN
                 │
         ┌───────┴───────┐
         ▼               ▼
      Correct         Incorrect
         │               │
         ▼               ▼
     Continue      Handle Problem
                         │
                         ▼
                Display Error Message

Exception Handling Keywords

C++ exception handling commonly uses three keywords: try, throw, and catch.

try
{
    // Code that may throw
}
catch (ExceptionType value)
{
    // Handle matching exception
}

throw 100;

Exception Handling Flow

When code inside a try block throws an exception, normal execution of that try block stops. C++ searches for a matching handler.

Program Starts
      │
      ▼
Enter try Block
      │
      ▼
Execute Code
      │
      ▼
Exception Thrown?
   ┌──┴──┐
   │     │
  No    Yes
   │     │
   ▼     ▼
Continue  Stop Remaining try Code
             │
             ▼
       Search for Handler
             │
             ▼
       Matching catch Found
             │
             ▼
        Execute Handler

Example 1: Basic Exception Handling

The following program throws an integer value and handles it with a matching catch block.

#include <iostream>

int main()
{
    try
    {
        throw 100;
    }
    catch (int number)
    {
        std::cout
            << "Exception: "
            << number;
    }

    return 0;
}

throw 100
    │
    ▼
Exception Type: int
    │
    ▼
catch (int number)
    │
    ▼
number = 100

Exception: 100

Example 2: Division by Zero

For integer arithmetic, division by zero is invalid and results in undefined behavior. The program can check the denominator before performing the division and throw an exception when the operation is invalid.

#include <iostream>

int main()
{
    int numerator = 20;
    int denominator = 0;

    try
    {
        if (denominator == 0)
        {
            throw "Division by zero error!";
        }

        std::cout
            << numerator / denominator;
    }
    catch (const char* message)
    {
        std::cout << message;
    }

    return 0;
}

denominator = 0
       │
       ▼
denominator == 0?
       │
      Yes
       │
       ▼
Throw Message
       │
       ▼
Catch const char*
       │
       ▼
Display Error

Division by zero error!

Example 3: Multiple Catch Blocks

A try block can be followed by multiple catch handlers. This allows different exception types to be handled differently.

#include <iostream>

int main()
{
    try
    {
        throw 25.5;
    }
    catch (int number)
    {
        std::cout
            << "Integer Exception";
    }
    catch (double number)
    {
        std::cout
            << "Double Exception";
    }

    return 0;
}

throw 25.5
     │
     ▼
Type: double
     │
     ▼
catch (int)
     │
  No Match
     │
     ▼
catch (double)
     │
   Match
     │
     ▼
Execute Handler

Double Exception

Catch-All Handler

A catch-all handler uses catch (...) and can handle exceptions that were not matched by earlier handlers associated with the same try block.

catch (...)
{
    std::cout
        << "Unknown exception occurred!";
}

try
{
    // Code that may throw
}
catch (int value)
{
    // Handle int
}
catch (double value)
{
    // Handle double
}
catch (...)
{
    // Handle anything else
}

Program Execution Flow

The complete exception-handling flow depends on whether an exception is thrown and whether a matching handler can be found.

Program Starts
      │
      ▼
Enter try Block
      │
      ▼
Execute Statements
      │
      ▼
Exception Thrown?
   ┌──┴──┐
   │     │
  No    Yes
   │     │
   ▼     ▼
Finish   Stop Remaining
try      try Statements
   │         │
   │         ▼
   │    Search for Handler
   │         │
   │         ▼
   │    Matching catch
   │         │
   │         ▼
   │    Execute Handler
   │         │
   └────┬────┘
        ▼
Continue After
Handler Sequence

Real-World Applications

Exception handling is useful when operations can fail in ways that should be reported to another part of the program.

User Interface
      │
      ▼
Business Logic
      │
      ▼
Service Layer
      │
      ▼
External Operation
      │
      ▼
Exceptional Failure
      │
      ▼
Exception Propagates
      │
      ▼
Appropriate Layer Handles It

Advantages of Exception Handling

Common Beginner Mistakes

int main()
{
    throw 100;

    // No handler exists
}

try
{
    throw 10;
}
catch (double value)
{
    // Does not handle the thrown int
}

try
{
    throw 10;

    // Not executed
    std::cout << "Hello";
}
catch (int value)
{
    std::cout << value;
}

// ❌ Incorrect
catch (...)
{
}

catch (int value)
{
}

// ✅ Correct
catch (int value)
{
}

catch (...)
{
}

Best Practices

#include <iostream>
#include <stdexcept>

int main()
{
    try
    {
        throw std::runtime_error(
            "Operation failed"
        );
    }
    catch (const std::exception& error)
    {
        std::cout << error.what();
    }

    return 0;
}

try
{
    // Operation
}
catch (const std::runtime_error& error)
{
    // Handle specific runtime error
}
catch (const std::exception& error)
{
    // Handle other standard exceptions
}
catch (...)
{
    // Final fallback
}

Frequently Asked Questions

Key Takeaways

Summary

Exception handling provides a structured mechanism for reporting and responding to exceptional situations in C++ programs.

The try keyword introduces code associated with handlers, throw signals an exception, and catch defines the code that handles a matching exception.

When an exception is thrown, the remaining statements in the current try block are skipped and C++ searches for a suitable handler. Different exception types can be handled by different catch blocks.

A catch-all handler written as catch (...) can process exceptions not matched by earlier handlers. It must appear after the specific handlers.

Exceptions can propagate through function calls. During this process, local automatic objects are destroyed as scopes are exited, a process known as stack unwinding.

Exception handling should be used for exceptional situations rather than ordinary control flow. Meaningful exception types, focused try blocks, appropriate handler placement, and RAII-based resource management help create safer designs.

C++ does not automatically turn every programming error into an exception. For example, integer division by zero is undefined behavior, so a program should detect the invalid denominator before performing the operation.

By understanding try, throw, catch, handler matching, catch-all handlers, propagation, and stack unwinding, you can design applications that respond to failures in a more controlled and maintainable way.

In the next lesson, you will learn about file handling and how C++ programs create, write, read, and manage files.