Date post: | 19-Jan-2016 |
Category: |
Documents |
Upload: | geoffrey-holt |
View: | 214 times |
Download: | 0 times |
CS212: Object Oriented Analysis and DesignLecture 19: Exception Handling
Recap of Lecture 18
• Virtual destructors
• Dispatching, single and multiple
• Downcasting
• Exception handling
Outline of Lecture 19
• Exception handling
• Try, throw catch
• Stack unwinding
• Exception classes
Introduction
• Exception handling allows you to manage run-time errors
• In an orderly fashion
• Program can automatically invoke an error-handling routine
• It automates much of the error-handling code
Error Conditions
• Division by 0, or values that are too large or small for a type
• No memory available for dynamic allocation
• Errors on file access, for example, file not found
• Attempt to access an invalid address in main memory
• Invalid user input
Traditional Error Handling
• Errors in function calls are indicated by special return values
• Global error variables or flags are set or unset when errors occur
if( func()> 0 )// Return value positive => o.k.
else// Treat errors
• Error variables and flags must also be checked after every corresponding action.
• Need to continually check for errors while a program is executing
Exception Handling Concept
• A new approach to error handling
• Keeping the normal functionality of the program separate from error handling
• Errors occurring in one particular part of the program
• Errors are reported to another part of the program, known as the calling environment
• The calling environment performs central error handling.
Exception handling in C++
• C++ exception handling is built upon three keywords: try, catch, and throw.
• Program statements to be monitored are contained in a try block
• If an exception occurs within the try block, it is thrown
• The exception is caught, using catch, and processed
Structure of try-catch block
try {// try block
}catch (type1 arg) {
// catch block}catch (type2 arg) {
// catch block}catch (type3 arg) {
// catch block}...catch (typeN arg) {
// catch block}
Code to be monitored
Possible to have more than one catch for a single try
Demonstration1
Throwing exception
• throw generates the exception specified by exception
• throw must be executed from within a try block itself
• From any function called from within the try block
• Demonstration2
• A try block can be localized to a function
• Demonstration3
Stack Unwinding
• The exception object is then thrown and the program control leaves the try block
• Any changes to the stack that took place after entering the try block are unwound
• The process of removing function entries from function call stack at run time is called Stack Unwinding
• Allows back out of the normal program flow in an orderly manner
• Demonstration
Searching for Handlers
• After the try block the PC searchers for the appropriate catch block
• Always performed sequentially beginning with the first catch block
• Exception declaration of the handler determines whether the handler should be executed
• Identical to the exception type thrown
• A base class of the exception type
• A base class pointer and the exception is a pointer to a derived class
Multiple catch Statements
• It is possible to have multiple condition to throw exception
• For individual throw statement, one catch statement is used
• Similar to switch statement
• Demonstration
Catch all/ Generic handler
• Similar to the tradition switch case, captures any type of exceptions (generic handler)
• A special syntax in the catch statement with an exception declaration consisting of just three dots.
• General exception handler to be defined last
catch( ... ){ // General handler for// all other exceptions}
Exception Classes
• Exception classes are defined to categorize exceptions
• throw statement is used to throw an object belonging to a specific exception class.
• An exception class need not contain data members or methods
• type, which is used by the calling environment to identify the error, is important
• Contains members that provide more specific information on the cause of the error
Continuing the Program
• After executing a handler, the program continues with the first statement following the catch blocks
• Unless the handler throws another exception
• Terminates the program
• After completing exception handling, the exception object that was thrown is destroyed
Catching Class Types
• An exception can be of class types that you create
• Most exceptions will be class types rather than built-in types
• To create an object that describes the error that occurred
• Information can be used by the exception handler to help it process the error
• Demonstration5
Nesting exception handling
• A try block can contain additional try blocks
• This allows using the handlers in a nested try block for special purpose error handling
• Leaving the handlers in the surrounding try block to deal with remaining errors
• You can also nest a try block within a catch block.
try{
// Type1 exceptions are thrown here.try{
// Type1 and Type2 exceptions are thrown here.}catch( Type2 e2){
// Type2 exceptions are pre-handled herethrow; // and thrown again.
}// Other Type1 exceptions can be thrown.
}catch( Type1 e1){
// Type1 exceptions are handled here.}catch(...){
// All remaining exceptions are handled here,// particularly Type2 exceptions.
}
Control transfer in nested case
Try blocks are nested and a throw occurs in a function called by an inner try block
try { func1(); try {
func2(); } catch (spec_err) {
/* ... */ } func3();
} catch (type_err) { /* ... */ } // if no throw is issued, control resumes here.
Standard exceptions
• C++ Standard library provides a base class
• Designed to declare objects to be thrown as exceptions
• Defined in the <exception> header
• This class has a virtual member function called “what”
• Override in derived classes to contain some sort of description of the exception
• Demonstration
Types of exceptions
Exception Description
bad_alloc thrown by new on allocation failure
bad_cast thrown by dynamic_cast when it fails in a dynamic cast
bad_exception thrown by certain dynamic exception specifiers
bad_typeid thrown by typeid
bad_function_call thrown by empty function objects
All exceptions thrown by components of the C++ Standard library throw exceptions derived from this exception class.
Thank youNext Lecture: Exception Handling