Exception Handling

EXCEPTION HANDLING

An exception is any unusual event, either erroneous or not, detectable by either hardware or software, that may require special processing.

WITHOUT EXCEPTION HANDLING

When an exception occurs, control goes to the operating system, where typically

• an error message is displayed

• the program is terminated

WITH EXCEPTION HANDLING

• Programs are allowed to trap exceptions.

• There is a possibility to fix the problem and continuing execution

Exception handling mechanism

To detect and report error, The error handling code performs the following task

1.  Find the problem (Hit the exception)

2. Inform that an error has occurred. (Throw the exception)

3. Receive the error information. (Catch the exception)

4. Take corrective actions. (Handle the exception).

Keywords in Exception Handling

·        try

·        throw

·        catch

TRY BLOCK -The keyword try is used to preface a block of statements (surrounded by braces) which may generate exceptions.

->When an exception is detected, it is thrown using a throw statement in the try block.

CATCH BLOCK - defined by the keyword catch „catches‟ the exception „thrown‟ by the throw statement in the try block, and handles it appropriately.

Exception Handling Syntax:

try                                                   //try block

{

…….

throw exception;  // Block of statements which detects and throws an exception

}

catch(type arg) // Catches exception

{

…….

…….. // Block of statements that handles the exception

}

Example:   

#include <iostream>     

int main()   

cout << “start”;   

try    

{        // start

a  try  block  cout  <<  Inside  try

block\n”;    

throw 100;  // throw an error

cout << “This will not execute”;

}       

catch (int i)

{        // catch an error

cout << “caught an exception “; cout << i ; cout << “End”; return 0;

}

}

Exception Types

Synchronous Exception:

•        Out of range

•        Over flow

Asynchronous Exception

•        Error that are caused beyond the control of the program

•        Keyboard interrupts

In C++ only synchronous exception can be handled.

Factors determining Exception

·        Division by zero

·        Access to an array outside of its bounds

·        Running out of memory

·        Running out of disk space

Need for Exception Handling

·  Dividing the error handling

·  Unconditional termination & programmer preferred termination

·    Separating error reporting and error handling

·  Object destroy problem

·        When the program enters the try block it is said to be in the guarded section.

·        In this program when the value of j is zero an exception is created and thrown.

·        Note that the statement after throw statement in try block is not executed.

·        Once the exception is thrown the catch block catches the value (here zero) and handles it.

·        After that the program continues its normal execution.

Functions Generating Exceptions

C++ allows functions to generate exceptions. These functions cannot be called as an ordinary function. Enclose the function call with a try catch block.

Syntax:

try

{ function(arg);

}

catch(type arg)

{

------

}

Throwing Mechanisms:

·        An exception is thrown by using the throw keyword from inside the try block.

·        A throw expression accepts one parameter, which is passed as an argument to the

exception handler.

Eg. throw b;

The throw statement will have the following.

Example:

·        throw (exception)

·        throw exception

·    throw

Catching Mechanisms

·        If the data type specified by a catch, matches that of the exception, then catch statement is executed.

·        When an exception is caught, arg will receive its value

Multiple Catch Statements

·        A try can have multiple catches

·        If there are multiple catches for a try, only one of the matching catch is selected and that corresponding catch block is executed.

Syntax:

try

{

any statements

if (some condition) throw value1;

else if (some other condition) throw value2;

else if (some last condition) throw valueN;

}

catch (type1 name)

{

any statements

}

catch (type2 name)

{

any statements

}

catch (typeN name)

{

any statements

}

Example:

#include<iostream.h>

void multiple_catch(int value)

{

try

{

if (value==0) //throw an int value throw 1;

else if (value==1) //throw a char throw „a‟;

else //throw float throw 1.1;

}

catch(char c)

{

cout<<”Character value is thrown” <<c;

}

catch(int i)

{

cout<<”Integer value is thrown”<<i;

}

catch(float f)

{

cout<<”Float value is thrown”<<f;

}

}

void main()

{

cout<<”Main Program”<<endl;

multiple_catch(0);

 multiple_catch(1);

 multiple_catch(5);

}

Rethrowing Exceptions

Syntax:

try

{

…. throw a;

}

catch (char c)

{

throw;        //rethrow same exception in catch block in main()

}

Example:

#include <iostream.h>

class sam

{

int erno;

public:

sam (int errno)

{

exno=errno;

}

void shoex()

{

cout<<”error no:”<<exno;

}

};

void ergen()

{

try

{

sam s1(20); int c;

 cin>>c; switch (c)

{

case 1: throw 10;

 case 2: throw „a‟;

 case 3: throw s1;

 case 4: throw “welcome”;

}

catch (int ie)

{

cout<<”ie”<<ie; throw; //rethrowing

}

catch (char ce)

{

cout <<”ce”<<ce; throw; //rethrowing

}

}

void main ()

{

try

{

ergen(); throw 10;

}

catch (int)

{

cout <<”caught integer”;

}

catch(char)

{

cout<<”caught char”;

}

catch (sam s2)

{

s2.show x();

}

Terminate Function

Terminate () is the function which calls abort() to exit the program in the event of run time error related to exceptions. The user can provide his or her own terminate function instead of built-in terminate.

Use:

Used to close all open files & deallocate resources before quitting the program.

Syntax: set_terminate (myterminate);

Unexpected Function

·        If a function throws an exception which is not allowed, a function unexpected () is called, which in turn calls abort.

·        We can use set_unexpected in a similar to set_terminate Syntax: set_unexcepted(my unexcepted);

Example:

#include <iostream.h>

void myunexpected ()

{

cout << "unexpected called\n";

throw 0;   // throws int (in exception-specification)

}

void myfunction () throw (int)

{

throw 'x'; // throws char (not in exception-specification)

}

int main (void)

{

set_unexpected (myunexpected);

try

{

myfunction();

}

catch (int)

{

cout << "caught int\n";

}

catch (...)

{

cout << "caught some other exception type\n";

}

return 0;

}

Uncaught Exception()

·        This function returns true if an exception has been thrown but not yet caught.

·        Once caught, the function returns false.

Syntax:

bool uncaught_exceptions. if (uncaught_exception(

))

{

//Do not call the function which might throw an exception

}

Otherwise

{

Follow the natural sequence of the destructor Algorithm

}