Exception Handling

Exception Handling

• Exception handling provides a way to handle runtime errors or exceptional conditions during program execution.
• Special code for handling exceptions are called exception handlers.

Why Use Exception Handling?

• Enables developers to separate error-handling code from regular code, making programs more robust and easier to debug.
• Functions can handle chosen exceptions, passing uncaught exceptions to the caller.
• Facilitates grouping of error types through hierarchies of exception objects, namespaces, or classes.

Key Concepts

• Exceptions: Errors or unexpected conditions during program execution (e.g., division by zero, file not found).
• Throwing an Exception: Signaling an exception using the throw keyword.
• Catching an Exception: Handling an exception using the try, catch, and throw mechanism.

Syntax

• try: Starts a block of code that may throw an exception.
• catch: Defines a block of code that handles the exception.
• throw: Throws an exception from a function.

Basic Structure of Exception Handling

• The basic structure includes a try block containing code that might throw an exception, an if statement to check for error conditions, and a throw statement to signal an exception when an error occurs.
• A catch block is then used to handle the exception.

try {
  // Code that might throw an exception
  if (error_condition) {
    throw exception; // throw an exception when error occurs
  }
}
catch (type_of_exception e) {
  // Code to handle the exception
}

Throwing

• Code detecting an exception must pass information to the handler using a throw statement.
• The type of information thrown by the throw statement can be of any type.

throw "Emergency!";
throw 12;

Catching

• A block of code that handles the exception is said to catch the exception and is named an exception handler.
• An exception handler is written to catch exceptions of a given type.

catch(char *str) {
  cout << str;
}

• The code above can only catch exceptions of the C-string type.
• Catch blocks are attached to a try block and handle exceptions thrown from that block.

Execution of Catch Blocks

• The catch block syntax is similar to that of a function.
• Has a formal parameter that is initialized to the value of the thrown exception before the block executes.

Connecting to the Handler

• Every catch block is attached to a try block of code to handling exceptions thrown from that block.

Flow Control

• The program encounters a throw statement inside a try block.
• The program evaluates the throw expression and exits the try block.
• The program selects an attached catch block that matches the type of the thrown value, placing the value in the catch block's formal parameter, and executes the catch block.

Uncaught Exceptions

• An exception is uncaught if no catch block with a matching data type is present, or if it was not thrown from within a try block.
• Encountering an uncaught exception will terminate the program.

Handling Multiple Exceptions

• Multiple catch blocks can be attached to the same block of code, each handling exceptions of different types.

try{...}
catch(int iEx) { cout << "int exception"; }
catch(char *strEx) { cout << "text exception"; }
catch (double dEx) { cout << "double exception"; }
catch (...) { cout << "default exception"; }

Throwing an Exception Class

• Exception classes can be defined and thrown.
• Catch blocks must be designed to catch objects of the exception class.
• Exception class objects can pass data to exception handlers via data members.

Exceptions and new

• The new operator throws an exception of type bad_alloc if it cannot allocate memory.
• #include <new> must be included to use bad_alloc.
• To detect memory allocation issues, invoke new from within a try block and use a catch block.

Nested Exception Handling

• try blocks can be nested in other try blocks and even in catch blocks

try{
  try { } catch(int i){ }
}
catch(char *s) { }

Finding an Exception Handler

• The compiler searches for a suitable handler attached to an enclosing try block.
• The search begins in the function where the exception was thrown.
• If there is no matching handler in the function, execution terminates, and the search continues at the point of the call in the calling function.

Unwinding the Stack

• An unhandled exception propagates backwards into the calling function and appears to be thrown at the point of the call.
• The computer terminates function calls and traces backward along the call chain until a matching handler is found or the call stack has been unwound.
• Unwinding of the call stack will result in program termination.

Rethrowing

• Allows an exception handler to perform tasks and then pass the exception to a handler in the calling environment.
• Use the throw; statement (without parameters) within a catch block to pass the exception to a handler in an outer block.

C++ Standard Exceptions

• std::exception class is the base class for standard exceptions
• Derived classes of std::exception implement specific types of exception.
• It has derived classes such as std::bad_alloc, std::domain_error, std::invalid_argument, and std::length_error.
• Standard exception classes enables a more structured approach to error handling.