exceptiondddddddddddddddddddddddddddddddddddddddd.ppt

PCCP, FPGDST 2003 2
© CDAC (Formerly NCST)
Objectives
 Concept of exceptions
–why a better error handling
mechanism is required
 C++ support for exceptions and
exception handling

PCCP, FPGDST 2003 3
Introduction
 Error free program operation is a dream
 Why error handling mechanism is
required
–To check the abnormality of program.
–To avoid the cascading effect of error.
–To avoid abnormal termination
 Proper corrective action has to be taken
 Errors have to be handled

PCCP, FPGDST 2003 4
C Mechanism
 Set a global error flag
 Expect the user to check after each operation
 Lot of responsibility placed on the user
 Example -
int fd;
fd = open(“hello.dat”, O_RDONLY);
if ( fd == -1 )
// do something
File *fp;
fp = fopen(“hello.dat”, “r”);
if ( fp == NULL )
if ( errno == FILENOTFOUND )
// do something
conventional error
handling

PCCP, FPGDST 2003 5
Java Mechanism
 Uses the special key word
– throw, try, catch, throws and finally
 Program inside a try block can throw error and can be caught ouside of that
block or in parent block.
void readReport(String filename){
try {
File file = new File(filename);
SimpleInput sin = new SimpleInput(file);
// read data from file
}
catch (FileNotFoundException fnfe) {
System.err.println(“Missing report file: ”+filename);
}
}

PCCP, FPGDST 2003 6
C++ Mechanism
 To handle the error uses the exception
 Program that finds a problem it cannot
cope with, throws an exception, hoping
that its caller can handle the problem
 Uses the key word
–try, catch, throw

PCCP, FPGDST 2003 7
Exception Handler
 Code block has to be willing to catch an
exception
 Block is called exception handler
 Specified using catch
 Must follow a try block or another
exception handler

PCCP, FPGDST 2003 8
exception that occurred
Illustration
try {
. . .
. . . // error occurred here
}
catch (...)
{
. . .
. . . // error handling code
}
try block
catch block

PCCP, FPGDST 2003 9
Exception Handler (contd…)
 try Block
– Contains code that can throw an exception
 catch Block
– Entered when an exception is thrown
– Parentheses of catch block contains an expression
Similar to method argument
– Specifies type of objects with which the handler
can be entered
catch (…) is default exception handler.
– Naming the argument is optional

PCCP, FPGDST 2003 10
Throwing an Exception
 Exception thrown using throw
statement
 Any exceptions thrown in the exception
handler must be dealt with by the caller
of the try block
 Exception caught by specifying type
 Object is thrown, not type

Example
try
{
Object myObj(”my value”);
throw myObj;
}
catch ( Object err )
{
// statements in which the thrown
Object exceptions are processed
cerr << err.m_msg << endl;
}
Object type
object
m_msg is a
public member
of Object

Searching
 Throwing and catching involves search for a
matching handler
 Search
– in the exception call chain
– from the throw point
 During search
– call stack is unwound
– destructors for local objects are invoked
 Handler not found
– The program will terminate abnormally

Example
#include <iostream.h>
#include <string>
class Object {
string name;
public:
Object(string name) : name(name) {
cout << "Object constructor of " <<name << "n";
}
Object(Object const &other) : name(other.name + "
(copy)") {
cout << "Copy constructor for " << name << "n";
}
~Object(){
cout << "Object destructor of " << name << "n";
}
void hello() {
cout << "Hello by " << name << "n";
}

Example
void fun() {
Object toThrow("'local object'");
cout << "Object fun() of " << name << "n";
throw toThrow;
}
}; //class Object ends:
int main(){
Object out("'main object'");
try {
out.fun();
}
catch (Object o) {
cout << "Caught exceptionn";
o.hello();
}
}

Output of Example
Object constructor of 'main object'
Object constructor of 'local object'
Object fun() of 'main object'
Copy constructor for 'local object' (copy)
Object destructor of 'local object'
Copy constructor for 'local object' (copy) (copy)
Caught exception
Hello by 'local object' (copy) (copy)
Object destructor of 'local object' (copy) (copy)
Object destructor of 'local object' (copy)
Object destructor of 'main object'

Handling Multiple Exceptions
 Discrimination between two exceptions
possible
 Add multiple catch blocks for a try
block
 Appropriate handler will be invoked
when the exception occurs

Handling Multiple Exceptions (contd…)
try {
// this code may throw different types of exceptions
}
catch (char *message) {
// code to process char pointers
}
catch (int value) {
// code to process ints
}
catch (...) {
// code to process other exceptions,
// often passing the exception on to outer
// level exception handlers:
throw;
}

Example
void f1() {
try {
Object toThrow("‘new object'");
throw toThrow;
} catch ( Object o ) {
o.hello();
throw “Caught Object exception”;
}
}
throw an
exception explicitly
catch exception, but
throw a different one

Example
void f2() {
try {
f1();
} catch ( char *errmsg ) {
// safely caught
}
}
exception caught

Nesting
 Exceptions can be nested
try {
// some code
try {
// some code
} catch ( InnerException ) {
// handle InnerException
}
} catch ( OuterException ) {
// handle OuterException
}

Exception Hierarchies
 Exceptions can be grouped
 Two ways
–define variations as enumeration
–derive using inheritance
 Organizing exceptions is important for
robustness of code

Grouping
 Exceptions can be grouped using enum
 Thrown exception object identified using
enum identifier

Example
enum NetworkError { HostNotFound,
BadPort };
try {
. . .
} catch ( NetworkError ne ) {
switch ( ne ) {
case HostNotFound : . . .; break;
case BadPort : . . .; break;
}
}

Hierarchies
 Exception hierarchies using inheritance
possible
 Use inheritance instead of enum
 More flexible and extensible
 Advantages of classes and the property
of inheritance can be used

Example
class NetworkError { };
class HostNotFound : public NetworkError { };
class BadPort : public NetworkError { };
try {
Socket s;
s.connect(“konark”, 80);
String buf = s.readInput();
}
catch ( HostNotFound ) {
}
catch ( BadPort ) {
}
catch ( NetworkError ) {
}

Exception Resolution
 Exceptions can be caught by a handler
using the base class rather than the
exact class
 Semantics for handler catching and
naming are identical to that of a function
 Pointers and references can be used to
avoid losing information

Exception Matching
 Order of handlers is important
 Handlers are tried in order

Example
class NetworkError { };
class HostNotFound : public NetworkError { };
class BadPort : public NetworkError { };
try {
Socket s; s.connect(“konark”, 80);
String buf = s.readInput();
}
catch ( NetworkError ) {
}
catch ( HostNotFound ) {
}
catch ( BadPort ) {
}
never
caught

Re-throwing an Exception
 Handler can re-throw an exception
 throw used without an argument
 Exception re-thrown is original
exception thrown

Example
void f1() {
try {
Object toThrow("‘new object'");
throw toThrow;
} catch ( Object o ) {
throw; // re-throw exception
}
}
try {
f1();
}
catch ( Object err ) { . . .}
original exception
caught

Exception specifications
 Set of exceptions that a function may throw,
can be specified as a part of the function
declaration.
void f(int a) throw(Exception1, ..) {…
 It guarantees that function will not throw any
other types of exception.
 If during execution function does something
that tries to abrogate the guarantee. The
attempt will be transferred to
std::unexpected()
 Std::unexpected => std::terminate()

Exception Specification & ptr to ()
 An exception specification can also be provided in the
declaration of a pointer to function.
 Assignment for pointers to function with exception
specification:
Example:
void func1(int) throw();
void func2(int)throw(string,exceptionType1);
pf = func1; /* okay: func1() is more
restrictive */
pf = func2; /* error: func2() is less
restrictive */
void (*pf)(int) throw (string);

Standard exceptions
Standard exception thrown by language:
Name Thrown by
Bad_alloc
Bad_cast
Bad_typeid
Bad_exception
new
dynamic_cast
typeid
Exception-
specificficat
ion

Standard Exceptions
 Thrown by the Standard Library
Name Thrown by
out_of_range
invalid_argument
overflow_error
ios_base::failure
at()
bitset<>::operator[]()
bitset constructor
bitset<>::to_ulong()
ios_base::clear

Standard exception class
class exception
{
Public:
exception() throw();
exception(const exception&) throw();
exception& operator =(const exception&)
throw();
virtual ~exception();
virtual const char* what() const throw();
Private:
//
};

Exception Class Hierarchy
exception
run time error
logic_error
bad_alloc
bad_exception
ios_base::failure
bad_typeid
bad_cast
range_error
underflow_
error
overflow_error
Invalid_arguments
out_of_range
domain_
error
lenth_error

Benefits
 Provides an alternative to traditional
techniques of error checking
 Explicit separation of error handling and
regular code possible
 More regular style of error handling
 Simplifies reuse

Summary
 Exception handling mechanism is better
 try, catch for exception handling
 Multiple exceptions can be handled
 Exception hierarchy can be created

exceptiondddddddddddddddddddddddddddddddddddddddd.ppt

More Related Content

Similar to exceptiondddddddddddddddddddddddddddddddddddddddd.ppt (20)

Recently uploaded (20)

exceptiondddddddddddddddddddddddddddddddddddddddd.ppt

Editor's Notes