Unit V Exception Handling

Exceptions: Exceptions are runtime anomalies or unusual conditions that a program may
encounter while executing .Anomalies might include conditions such ass division by zero,
accessing an array outside of its bounds or running out of memory or disk space. When a
program encounters an exception condition, it must be identified and handled.

Exceptions provide a way to transfer control from one part of a program to another. C++
exception handling is built upon three keywords: try, catch, and throw.

Types of exceptions:There are two kinds of exceptions

1.Synchronous exceptions

2.Asynchronous exceptions

1.Synchronous exceptions:Errors such as “Out-of-range index” and “over flow” are synchronous
exceptions

2.Asynchronous exceptions: The errors that are generated by any event beyond the control of
the program are called asynchronous exceptions

The purpose of exception handling is to provide a means to detect and report an exceptional
circumstance

Exception Handling Mechanism:

An exception is said to be thrown at the place where some error or abnormal condition is
detected. The throwing will cause the normal program flow to be aborted, in a raised exception.
An exception is thrownprogrammatic, the programmer specifies the conditions of a throw.

In handled exceptions, execution of the program will resume at a designated block of code,
called a catch block, which encloses the point of throwing in terms of program execution. The
catch block can be, and usually is, located in a different function than the point of throwing.

C++ exception handling is built upon three keywords: try, catch, and throw.

Try is used to preface a block of statements which may generate exceptions. This block of
statements is knownas try block. When an exception is detected it is thrown by using throw
statement in the try block.

Catch block catches the exception thrown by throw statement in the try block and handles it
appropriately.
The structure ofthese two blocks is shown below:

......

......

try

......

throw exception //Block ofstatements which detects and throws an exception

.....

catch(type arg)

...... //Blockof statements that handles the exception

......

......

......
When the try block throws an exception, theprogram control leaves the try blockand enters the
catch statement ofthe catch block. Here exception is nothing but an object used to transmit
theinformation about a problem. If the type of object thrown matches the arg typeof the catch
statement then catchblock is executed for handling the exception.

A program is givenbelow that will explain you that how actually exception handling is done in
C++.

#include<iostream>

using namespace std;

int main()

int x,y,z;

cout<<“Enter the values of x and y:”;

cin>>x>>y;

z=x-y;

try

if(z!=0)

cout<<“Result(x/z)=”<<x/z;

else //division by zero exception

throw(z); //throws int object

catch(int) //catches the exception

{
cout<<“Exception caught: z=”<<z;

return 0;

Outputs of the above program is shown below:

For First Run

For second Run

Multiple catch statements:

A try block can be followed by one or more catch blocks. Each catch block must contain a
different exception handler. So, if you have to perform different tasks at the occurrence of
different exceptions.

try

{
//try block

catch(data type1 arg)

//catch block1

catch(data type2 arg)

//catch block2

………………

……………..

catch(data typeN arg)

//catch blockN

• When an exception is thrown, the exception handler are searched in order fore an appropriate
match.

• It is possible that arguments of several catch statements match the type of an exception. In
such cases the first handler that matches the exception type is executed

Write a Program to catch multiple catch statements

#include<iostream.h>

void test(int x)

try

if(x==1) throw x;

else

if(x==0) throw 'x';

else

if(x==-1) throw 1.0;

cout<<"end of try block"<<endl;

catch(char c)

cout<<"caught a character"<<endl;

catch(int m)

cout<<"caught an integer"<<endl;

catch(double d)

cout<<"caught a double"<<endl;

}
int main()

test(1);

test(0);

test(-1);

test(2);

return 0;

Output:

caught an integer

caught a character

caught a double

end of try block

Catch All Exceptions:

All possible types of exceptions and therefore may not be able to design independent catch
handlers tocatch them. In such circumstances, we can force a catch statement to catch all
exceptions instead of a certain type alone.

catch(…)

………

Write a Program to catch all exceptions

#include<iostream.h>

void test(int x)

{
try

if(x==0) throw x;

if(x==0) throw 'x';

if(x==-1) throw 1.0;

catch(...)

cout<<"caught exception"<<endl;

int main()

test(-1);

test(0);

test(1);

return 0;

Re-throwing an Exception:

It is possible to pass exception caught by a catch block again to another exception handler. This
is known as Re-throwing.

#include <iostream>

using namespace std;

void MyHandler()

{
try

throw "hello";

catch (const char*)

cout <<"Caught exception inside MyHandler\n";

throw; //rethrow char* out of function

int main()

cout<< "Main start...."<<endl;

try

MyHandler();

catch(const char*)

cout <<"Caught exception inside Main\n";

cout << "Main end";

return 0;

Specifying Exceptions:
Specification of exception restrict functions to throw some specified exceptions only with the
use of throw(exception list) in the the header of the function.

General form

Type function_name(argument list) throw(exceptions -list)

Statements

try

statements

Exception specification Meaning

throw() The function does not throw any e

throw(...) The function can throw an except

The function can throw an except

throw(type)
type.

Example Description

void Funct() throw(int) The function may throw an int ex

void Funct() throw() The function will throw no except

 The function may throw a char* a
void Funct() throw(char*, T)
user defined type exception.

void Funct() or void Funct(...) The function may throw anything

// Another sample function f3() that

//calls f2() and handles exception

Stack unwinding: //thrown by f1()
When we call some functions, it stores the address into call stack, and

after coming back from the functions, pops out the address to start the
void f3() {
work where it was left of.
cout<<"\n f3() Start ";
The stack unwinding is a process where the function call stack entries

try {
are removed at runtime. To remove stack elements, we use exceptions.

If an exception is thrown from the inner function, then all of the entries
f2();
of the stack is removed and return to the main invoker function.

}
So exception handling involves Stack Unwinding if exception is not

handled in same function (where it is thrown).

catch(int i){

cout<<"\n Caught Exception: "<<i;

Explanation
}// Example Exception Specification
In the above program, when f1() throws exception, its entry is removed

cout<<"\n f3() End";

#include <iostream>
from the function call stack (because it f1() doesn’t contain exception

}using namespace std;

handler for the thrown exception), then next entry in call stack is looked for

exception handler. The next entry is f2(). Since f2() also doesn’t have
int main() {function
// handler
f3();
void handler() {
}cout<<"In the handler()\n"; }
handler, its entry is also removed from function call stack. The next entry in

function call stack is f3(). Since f3() contains exception handler, the catch

block inside f3() is executed, and finally the code after catch block.

Standard Exceptions :

In C++ standard exceptions are defined in <exception> class that we can use inside our
programs. The arrangement of parent-child class hierarchy is shown below:

1 std::exception

An exception and parent class of all the standard C++

2 std::bad_alloc

This can be thrown by new.

3 std::bad_cast

This can be thrown by dynamic_cast.

4 std::bad_exception

This is useful device to handle unexpected except

program.
5 std::bad_typeid

This can be thrown by typeid.

6 std::logic_error

An exception that theoretically can be detected by read

7 std::domain_error

This is an exception thrown when a mathematically in

used.

8 std::invalid_argument

This is thrown due to invalid arguments.

9 std::length_error

This is thrown when a too big std::string is created.

10 std::out_of_range

This can be thrown by the 'at' method, for example a

std::bitset<>::operator[]().
11 std::runtime_error

An exception that theoretically cannot be detected by rea

Example for Exception Object
12 std::overflow_error

This#include
is thrown<iostream>
if a mathematical overflow occurs.

#include<exception>
13 std::range_error
int main()
using namespace std;
This is occurred { when you try to store a value which is ou
class ZeroException :public exception
14 std::underflow_error try
{
This is thrown {if a mathematical underflow occurs.
public:
int a,b;
const char* what()
Exception Objects
cout<<"Enter a and b:"<<endl;
The C++ Standard{ library provides a base class specifically designed to declare objects to be
cin>>a>>b;
thrown as exceptions.It is called std::exception and is defined in the <exception> header.

return "Zero division error";

This class has a virtual member function called what() that returns a null-terminated character
sequence (of type char *) and that if(b==0)
can be overwritten in derived classes to contain some sort of
} exception.
description of the

{
};
ZeroException obj;

throw obj;

else

cout<<"a/b = "<<a/b<<endl;