Exception Handling

Exception Handling is a type of error-checking, available in many programming languages

Exception - some sort of problem or error that occurs during a program's execution
Many error situations could occur besides those that we usually check for (usually related to things like user input)
Exception handler - a piece of code that resolves an exception situation
Typical error-checking often intermixed with the tasks of a program (if-statements, etc)

Exception handlers are intended to be separate from the main tasks

Why?

Intermixing program logic with the error-checking code can sometimes make programs hard to read, debug, etc.
Many potential problems are very infrequent
Exception handlers are separate from main tasks of a program

can improve clarity and modifiability

Exception handling can improve a program's fault tolerance

When?

This doesn't mean that exception handlers should be used in all cases. Sometimes conventional error-checking is more appropriate
Exception handling best for problems that occur infrequently
Exception handling is good for situations in which the error doesn't need to be handled in the same block in which it occurred

User input checking, for instance, would not fall into this category -- best to use conventional error-checking here
Errors that will result in termination of the program, for instance, would fall into this category

Good for setting up uniform techniques for error-handling when many programmers and multiple modules are involved.

How?

Reserved words in C++: try, throw, catch
try blocks

consists of keyword try and a block of code { } inside set braces
encloses the statements that might cause exceptions

catch blocks

1 or more catch blocks follow a try block. (also code enclosed in { } set braces)
each catch block is an exception handler
a catch block has a single parameter (with type listed)

if an exception occurs in a try block

the try block immediately ends
program attempts to match the exception to one of the catch handlers (based on type of item thrown)
if a match is found, the code in the catch block executes
only one catch block will be matched, if any
program control resumes after the last catch block

if no exceptions occur in a try block, the catch blocks are skipped
a point where an exception occurs is the throw point

keyword throw used to "throw" a specific kind of exceptionto be caught

In C++, there is a standard library with pre-built exception classes. The primary base class is called exception, and comes from here:
```
 #include <exception>
 using std::exception;
```
When a function intends to throw an exception back to the caller (i.e. not handled internally), it's good to tell the caller what to expect. Do this with a throw list when declaring:
```
  // this becomes part of the function's declaration
  void someFunction() throw (DivideByZero, SomeOtherException);
```
This can be used to limit the type of exceptions that a function is allowed to throw (and provides better information to the caller). Look at the following examples:
```
  void someFunction1() throw();		// empty throw list
  void someFunction2();			// no throw list
```
The first function (with empty throw list) can throw no exceptions to the outside. The second (with no throw list) could throw any kind -- no limits

Simple Example - note that this is just a toy example to illustrate the syntax and workings of try/catch blocks. This is not a situation in which one would likely choose to use exception handlers over conventional error checking. This just makes understanding the syntax easy.

Exception Handling

Exception handling examples in textbook (Savitch)

A few code examples from Deitel C++ (old text)