Rossella Lau Lecture 9, DCO10105, Semester B,2005-6 DCO10105 Object-Oriented Programming and Design Lecture 9: Application with Exception Handling

Rossella Lau Lecture 9, DCO10105, Semester B,2005-6

DCO10105 Object-Oriented Programming and Design

Lecture 9: Application with Exception Handling

Popular usage of polymorphism in applicationsException handling

-- By Rossella Lau


Polymorphism – many types Same classes can play as different types (of ancestors)

• Static binding with pointer Same expressions can perform different operations

• Dynamic binding with pointer and virtual function

• Functions of sub-class can override the function with identical signature in the base class

• Samples in bindingPlayer3.cpp: donald->print() can invoke print() in Donald and print() in Dewey according to the actual object’s type

Polymorphism


Popular usage of polymorphism

Data in the same family class can be placed into a single container

E.g., vector<Publication*> publications; To add a publication: publications.push_back(new Publication);

Book is a Publication: publications.push_back(new Book);

Then, a simple loop can print different details: for ( int i=0; i < publications.size(); i++) publications[i]->print();


The sample application: Mini book shop


Details of the Publication family


The sample program set

The application: bookshop.cpp

Classes: Publication.h Book.h Magazine.h Catalog.h OrderItem.h Order.h Sales.h InputException.h


Input checkBefore a datum can be input, one

should also guarantee the input device works properly

In C++, some user input can put the input device (istream) into a fail state and it cannot work properly; see slide 6-8 of Lecture 2

Then, a user input involves data domain check

A popular process: uses a loop to prompt user until a correct input is entered

bool done = false;do { … // user prompt … // accept input … // device check // domain check if (……) // correct done = true; else … // error } while (!done)


Exception handling

Error state or invalid input is an undesirable situation that makes program logic complicated, and sometimes disturbs the logic of normal operations

OOP uses exception handling to manage undesirable situations

System exceptions: logic_error & runtime_error• Some popular derived sub-classes: invalid_argument,

out_of_range, overflow_error, underflow_error User defined exceptions: a user can use basic data types as

exceptions or create its own exception classes


Exceptions

Some system functions will throw exception(s) to allow the calling function to notify there is an exception (unexpected result) from the function

type funID(…) throw exception1, exception2, … {}

A user can also throw exceptions to have systematic exception handling: throw exception;

To manage the exception: use try -- catch


A simple example

try { cin >> input; if (!cin) throw InputException(); //domain check if (0 <= input && 7 >= input) done = true; else throw InputException("Invalid choice!"); } catch (InputException ie) { cerr << ie.what() << endl; const int DEFAULT_LINE_LENGTH = 100; cin.clear(); cin.ignore (DEFAULT_LINE_LENGTH, '\n'); }


The sample user defined exception

class InputException {

private: string message;

public: InputException(string str="Input Error!"): message(str) {} string what() {return message; }

};

System exception classes usually provide a service function what() to return the error message


Exceptions

Exception: undesirable event detectable during program execution

If exceptions occurred during execution Programmer-supplied code terminated the program or Program terminated with an appropriate error message

Can add exception-handling code at point where an error can occur

(Malik’s slide: 16-4)

Example 16-1,2: Ch16_Ex1.cpp, Ch16_Ex2.cpp


Handling Exceptions within a Program (continued)

Function assert: Checks if an expression meets certain condition(s) If conditions are not met, it terminates the program

Example: division by 0 If divisor is zero, assert terminates the program with an

error message


Example 16-3: Ch16_Ex3.cpp


C++ Mechanisms of Exception Handling

The try/catch block handles exceptions

Exception must be thrown in a try block and caught by a catch block

C++ provides support to handle exceptions via a hierarchy of classes



try/catch Block

Statements that may generate an exception are placed in a try block

The try block also contains statements that should not be executed if an exception occurs

The try block is followed by one or more catch blocks



try/catch Block (continued)

The catch block:

Specifies the type of exception it can catch

Contains an exception handler

If the heading of a catch block contains ... (ellipses) in place of parameters

Catch block can catch exceptions of all types



General syntax of the try/catch block:(Malik’s slide: 16-9)



If no exception is thrown in a try block

All catch blocks for that try block are ignored

Execution resumes after the last catch block

If an exception is thrown in a try block

Remaining statements in that try block are ignored


Exercise: 16:2



The program searches catch blocks in order, looking for an appropriate exception handler

If the type of thrown exception matches the parameter type in one of the catch blocks:

Code of that catch block executes

Remaining catch blocks are ignored



Throwing an Exception For try/catch to work, the exception must be thrown

in the try block

General syntax to throw an exception is:

throw expression;

where expression is a constant value, variable, or object


Example 16-5,6,7: Ch16_Exp5,6,7.cpp


Throwing an Exception (continued) The object being thrown can be

Specific object

Anonymous object

In C++

An exception is a value

throw is a reserved word



Throwing an Exception:



Order of catch Blocks Catch block can catch

All exceptions of a specific type All types of exceptions

A catch block with an ellipses (three dots) catches any type of exception

In a sequence of try/catch blocks, if the catch block with an ellipses is needed It should be the last catch block of that sequence


Exercise: 16:3


Using try/catch Blocks in a Program: (Malik’s slide: 16-16)


Using C++ Exception Classes

C++ provides support to handle exceptions via hierarchy of classes

The function what returns the string containing exception object thrown by C++’s built-in exception classes

The class exception is: The base class of the exception classes provided by C++ Contained in the header file exception



Using C++ Exception Classes (continued)

Two classes derived from exception:

logic_error

runtime_error

logic_error and runtime_error are defined in header file stdexcept

The class invalid_argument deals with illegal arguments used in a function call




The class out_of_range deals with the string subscript out_of_range error

The class length_error handles the error if

A length greater than the maximum allowed for a string object is used





If the operator new cannot allocate memory space It throws a bad_alloc exception

The class runtime_error deals with errors that occur only during program execution

Classes overflow_error and underflow_error Deal with arithmetic overflow and under-flow exceptions Derived from the class runtime_error



Creating Your Own Exception Classes Programmers can create exception classes to handle

exceptions not covered by C++’s exception classes and their own exceptions

C++ uses the same mechanism to process the exceptions you define as for built-in exceptions

You must throw your own exceptions using the throw statement

Any class can be an exception class


Example 16-10-13: Ch16_Ex10-13.cpp


Rethrowing and Throwing an Exception

When an exception occurs in a try block Control immediately passes to one of the catch blocks

A catch block either Handles the exception or partially processes the

exception and then rethrows the same exception OR Rethrows another exception for the calling

environment to handle



Rethrowing and Throwing an Exception (continued)

The general syntax to rethrow an exception caught by a catch block is:

throw;

(in this case, the same exception is rethrown) or:

throw expression;

where expression is a constant value, variable, or object



Rethrowing and Throwing an Exception (continued)

The object being thrown can be

A specific object

An anonymous object

A function specifies the exceptions it throws in its heading using the throw clause




Exception Handling Techniques

When an exception occurs, the programmer usually has three choices:

Terminate the program

Include code to recover from the exception

Log the error and continue



Terminate the Program

In some cases, it is best to let the program terminate when an exception occurs

For example, if the input file does not exist when the program executes

There is no point in continuing with the program

The program can output an appropriate error message and terminate



Fix the Error and Continue In some cases, you will want to handle the exception

and let the program continue

For example, if a user inputs a letter in place of a number

The input stream will enter the fail state

You can include the necessary code to keep prompting the user to input a number until the entry is valid


Example 16-16: Ch16_Ex16.cpp


Log the Error and Continue (continued)

For example, if your program is designed to run a nuclear reactor or continuously monitor a satellite

It cannot be terminated if an exception occurs

When an exception occurs

The program should write the exception into a file and continue to run



Summary

Polymorphism provides dynamic binding which reduces programming efforts for different data types within the same family

To manage an application better, exception handling should be employed


Reference

Malik: 16

Sample program set (mini book shop): bookShop.cpp, Publication.h, Book.h, Magazine.h,

Catalog.h, OrderItem.h, Order.h, Sales.h, InputException.h

-- END --

Documents

Rossella Lau Lecture 9, DCO10105, Semester B,2005-6 DCO10105 Object-Oriented Programming and Design Lecture 9: Application with Exception Handling