Exception Handling
23.1 Introduction
Errors can be dealt with at place error occurs
Easy to see if proper error checking implemented
Harder to read application itself and see how code works
Exception handling
Makes clear, robust, fault-tolerant programs
C++ removes error handling code from "main line" of program
Common failures
new not allocating memory
Out of bounds array subscript
Division by zero
Invalid function parameters
23.1 Introduction (II)
Exception handling - catch errors before they occur
Deals with synchronous errors (i.E., Divide by zero)
Does not deal with asynchronous errors - disk I/O completions,
mouse clicks - use interrupt processing
Used when system can recover from error
Exception handler - recovery procedure
Typically used when error dealt with in different place than where it
occurred
Useful when program cannot recover but must shut down cleanly
Exception handling should not be used for program
control
Not optimized, can harm program performance
23.1 Introduction (III)
Exception handling improves fault-tolerance
Easier to write error-processing code
Specify what type of exceptions are to be caught
Most programs support only single threads
Techniques in this chapter apply for multithreaded OS as well
(windows NT, OS/2, some UNIX)
Exception handling another way to return control
from a function or block of code
23.2 When Exception Handling Should Be Used
Error handling should be used for
Processing exceptional situations
Processing exceptions for components that cannot handle them directly
Processing exceptions for widely used components (libraries, classes,
functions) that should not process their own exceptions
Large projects that require uniform error processing
23.3 Other Error-Handling Techniques
Use assert
If assertion false, the program terminates
Ignore exceptions
Use this "technique" on casual, personal programs - not commercial!
Abort the program
Appropriate for nonfatal errors give appearance that program functioned correctly
Inappropriate for mission-critical programs, can cause resource leaks
Set some error indicator
Program may not check indicator at all points there error could occur
23.3 Other Error-Handling Techniques (II)
Test for the error condition
Issue an error message and call exit
Pass error code to environment
setjump and longjump
In <csetjmp>
Jump out of deeply nested function calls back to an error handler.
Dangerous - unwinds the stack without calling destructors for automatic objects (more
later)
Specific errors
Some have dedicated capabilities for handling them
If new fails to allocate memory new_handler function executes to deal with
problem
23.4 Basics of C++ Exception Handling: try,
throw, catch
A function can throw an exception object if it
detects an error
Object typically a character string (error message) or class
object
If exception handler exists, exception caught and handled
Otherwise, program terminates
23.4 Basics of C++ Exception Handling: try,
throw, catch (II)
Format
Enclose code that may have an error in try block
Follow with one or more catch blocks
Each catch block has an exception handler
If exception occurs and matches parameter in catch block,
code in catch block executed
If no exception thrown, exception handlers skipped and
control resumes after catch blocks
throw point - place where exception occurred
Control cannot return to throw point
23.5 A Simple Exception-Handling Example: Divide
by Zero
Look at the format of try and catch blocks
Afterwards, we will cover specifics
23.6 Throwing an Exception
throw - indicates an exception has occurred
Usually has one operand (sometimes zero) of any type
If operand an object, called an exception object
Conditional expression can be thrown
Code referenced in a try block can throw an exception
Exception caught by closest exception handler
Control exits current try block and goes to catch handler (if it
exists)
Example (inside function definition)
if ( denominator == 0 )
throw DivideByZeroException();
Throws a dividebyzeroexception object
23.6 Throwing an Exception (II)
Exception not required to terminate program
However, terminates block where exception occurred
23.7 Catching an Exception
Exception handlers are in catch blocks
Format: catch( exceptionType parameterName){
exception handling code
}
Caught if argument type matches throw type
If not caught then terminate called which (by default) calls
abort
Example:
catch ( DivideByZeroException ex) {
cout << "Exception occurred: " << [Link]() <<'\n'
}
Catches exceptions of type DivideByZeroException
23.7 Catching an Exception (II)
Catch all exceptions
catch(...) - catches all exceptions
You do not know what type of exception occurred
There is no parameter name - cannot reference the object
If no handler matches thrown object
Searches next enclosing try block
If none found, terminate called
If found, control resumes after last catch block
If several handlers match thrown object, first one found is
executed
23.7 Catching an Exception (III)
catch parameter matches thrown object when
They are of the same type
Exact match required - no promotions/conversions allowed
The catch parameter is a public base class of the thrown
object
The catch parameter is a base-class pointer/ reference
type and the thrown object is a derived-class pointer/
reference type
The catch handler is catch( ... )
Thrown const objects have const in the parameter type
23.7 Catching an Exception (IV)
Unreleased resources
Resources may have been allocated when exception thrown
catch handler should delete space allocated by new and
close any opened files
catch handlers can throw exceptions
Exceptions can only be processed by outer try blocks
23.8 Rethrowing an Exception
Rethrowing exceptions
Used when an exception handler cannot process an
exception
Rethrow exception with the statement:
throw;
No arguments
If no exception thrown in first place, calls terminate
Handler can always rethrow exception, even if it
performed some processing
Rethrown exception detected by next enclosing try
block