exception handling in cpp

Chap 13
Exception handling
1 By:-Gourav Kottawar

Contents
13.1 Exception Handling Fundamentals
13.2 The try Block, the catch Exception Handler
13.3 The throw Statements
13.4 The try/throw/catch sequence
13.5 Exception Specification
13.6 Unexpected Exception
13.7 Catch – All Exception Handlers
13.8 Throwing an exception from handler
13.9 Uncaught Exception

3
Syntax Errors, Runtime Errors, and Logic
Errors
three categories of errors:
syntax errors, runtime errors, and logic
errors.
Syntax errors arise because the rules of the
language have not been followed. They are
detected by the compiler.
 Runtime errors occur while the program is
running if the environment detects an operation
that is impossible to carry out.
Logic errors occur when a program doesn'tBy:-Gourav Kottawar

Introduction
 Allows to manage run time errors
 Using exception handling program can
invoke automatically invoke an error
handling routine when an error occurs.
 Automates error handling code.

 Based on three try , catch and throw
 Code that we want to monitor for exceptions must
have been executed from within try block.
 Functions called from try block may also throw an
exception.
 Exception that can be thrown by the monitored
code are caught by a catch statement.

 General syntax –
try
{
//try block
}catch(type1 args) {
//catch block
}
catch(type2 args) {
//catch block
}
catch(type3 args) {
//catch block
}
.
.
.
.
catch(typeN args) {
//catch block
}
General form of throw
throw exception

#include<iostream.h>
#include<stdlib.h>
int main()
{
cout<<"n Startn";
try {
cout<<"Inside try
blockn";
throw 100;
cout<<"This will not
execute";
}
catch(int i)
{
cout<<"Caught exception
value is :";
cout<<i<<"n";
}
cout<<"n End";
return 0;
}7 By:-Gourav Kottawar

#include<iostream.h>
#include<stdlib.h>
int main()
{
cout<<"n Startn";
try {
cout<<"Inside try
blockn";
throw 100;
cout<<"This will not
execute";
}
catch(int i)
{
cout<<"Caught exception
value is :";
cout<<i<<"n";
}
cout<<"n End";
return 0;
}
//Output
Start
Inside try block
Caught exception value
is 100
End

#include <iostream.h>
int main()
{
int StudentAge;
cout << "Student Age: ";
cin >> StudentAge;
try
{
if(StudentAge < 0)
throw;
cout << "nStudent Age: " << StudentAge << "nn";
}
catch(...)
{
}
cout << "n"; return 0;
}

// This example will not work.
#include <iostream>
using namespace std;
int main()
{
cout << "Startn";
try { // start a try block
cout << "Inside try blockn";
throw 100; // throw an error
cout << "This will not execute";
}
catch (double i) { // won't work for an int
exception
cout << "Caught an exception -- value is: ";
cout << i << "n";
}
cout << "End";
return 0;
}
Start
Inside try block
Abnormal program
termination

An exception can be thrown from outside the try block as long
as it is thrown by a function that is called from within try
block./* Throwing an exception from a
function outside the try block.
*/
#include <iostream>
void Xtest(int test)
{
cout << "Inside Xtest, test is: " << test
<< "n";
if(test) throw test;
}
int main()
{
cout << "Startn";
Xtest(0);
Xtest(1);
Xtest(2);
}
catch (int i) { // catch an error
cout << "Caught an exception --
value is: ";
cout << i << "n";
}
cout << "End";
return 0;
}

An exception can be thrown from outside the try block as long
as it is thrown by a function that is called from within try
block./* Throwing an exception from a
function outside the try block.
*/
#include <iostream>
void Xtest(int test)
{
cout << "Inside Xtest, test is: " << test
<< "n";
}
int main()
{
cout << "Startn";
Xtest(0);
Xtest(1);
Xtest(2);
}
cout << "Caught an exception --
value is: ";
cout << i << "n";
}
cout << "End";
return 0;
} Start
Inside try block
Inside Xtest, test is: 0
Inside Xtest, test is: 1
Caught an exception -- value is: 1
End

A try block can be localized to a function. When this is the case,
each time the function is entered, the exception handling relative to that
function is reset.
#include <iostream>
// Localize a try/catch to a function.
void Xhandler(int test)
{
try{
}
catch(int i) {
cout << "Caught Exception #: " << i <<
'n';
}
}
int main()
{
cout << "Startn";
Xhandler(1);
Xhandler(2);
Xhandler(0);
Xhandler(3);
cout << "End";
return 0;
}

A try block can be localized to a function. When this is the case,
each time the function is entered, the exception handling relative to that
function is reset.
#include <iostream>
// Localize a try/catch to a function.
{
try{
}
catch(int i) {
cout << "Caught Exception #: " << i <<
'n';
}
}
int main()
{
cout << "Startn";
Xhandler(1);
494 C + + : T h e C o m p l e
t e R e f e r e n c e
Xhandler(2);
Xhandler(0);
Xhandler(3);
cout << "End";
return 0;
}This program displays this
output:
Start
Caught Exception #: 1
Caught Exception #: 314 By:-Gourav Kottawar

a catch statement will be executed only if it catches an exception. Otherwise,
execution simply bypasses the catch altogether.
int main()
{
cout << "Startn";
cout << "Still inside try blockn";
}
cout << "Caught an exception -- value is:
";
cout << i << "n";
}
C h a p t e r 1 9 : E x c e p t i o n H a n d l
i n g 495
cout << "End";
return 0;
}
Start
Inside try block
Still inside try block
End
the catch statement is bypassed by the flow of
execution

Catching Class Types
 Exception can be of any type.
 Mostly it is user defined type. i.e. class
 the most common reason that you will want to
define a class type for an exception is to create
an object that describes the error that occurred.
This information can be used by the exception
handler to help it process the error.

// Catching class type
exceptions.
#include <cstring.h>
class MyException {
public:
char str_what[80];
int what;
MyException()
{
*str_what = 0; what = 0;
}
MyException(char *s, int e)
{
strcpy(str_what, s);
what = e;
}
};
int main()
{
int i;
try {
cout << "Enter a positive number:
";
cin >> i;
if(i<0)
throw MyException("Not
Positive", i);
}
catch (MyException e) { // catch
an error
cout << e.str_what << ": ";
cout << e.what << "n";
}
return 0;
}

// Catching class type
exceptions.
#include <cstring.h>
class MyException {
public:
char str_what[80];
int what;
MyException()
{
*str_what = 0; what = 0;
}
MyException(char *s, int e)
{
strcpy(str_what, s);
what = e;
}
};
int main()
{
int i;
try {
cout << "Enter a positive number:
";
cin >> i;
if(i<0)
throw MyException("Not
Positive", i);
}
catch (MyException e) { // catch
an error
cout << e.str_what << ": ";
cout << e.what << "n";
}
return 0;
}
Enter a positive number: -4
Not Positive: -4

Using Multiple catch Statements
#include <iostream>
{
try{
else throw "Value is zero";
}
catch(int i) {
cout << "Caught Exception #: "
<< i << 'n';
}
catch(const char *str) {
cout << "Caught a string: ";
cout << str << 'n';
}
}
int main()
{
cout << "Startn";
Xhandler(1);
Xhandler(2);
Xhandler(0);
Xhandler(3);
cout << "End";
return 0;
}

Using Multiple catch Statements
#include <iostream>
{
try{
else throw "Value is zero";
}
catch(int i) {
cout << "Caught Exception #: "
<< i << 'n';
}
catch(const char *str) {
cout << "Caught a string: ";
cout << str << 'n';
}
}
int main()
{
cout << "Startn";
Xhandler(1);
Xhandler(2);
Xhandler(0);
Xhandler(3);
cout << "End";
return 0;
}
Start
Caught a string: Value is zero
End

Handling Derived-Class Exceptions
// Catching derived
classes.
class B
{
};
class D: public B
{
};
int main()
{
D derived;
try {
throw derived;
}
catch(B b) {
cout << "Caught a base
class.n";
}
catch(D d) {
cout << "This won't execute.n";
}
return 0;
}

Catching All Exceptions
// This example catches all
exceptions.
{
try{
if(test==0) throw test; // throw int
if(test==1) throw 'a'; // throw char
if(test==2) throw 123.23; // throw
double
}
catch(...) { // catch all exceptions
cout << "Caught One!n";
}
}
int main()
{
cout << "Startn";
Xhandler(0);
Xhandler(1);
Xhandler(2);
cout << "End";
return 0;
}

Catching All Exceptions
// This example catches all
exceptions.
{
try{
double
}
catch(...) { // catch all exceptions
}
}
int main()
{
cout << "Startn";
Xhandler(0);
Xhandler(1);
Xhandler(2);
cout << "End";
return 0;
}
//output
Start
Caught One!
Caught One!
Caught One!
End23 By:-Gourav Kottawar

// This example uses catch(...) as a
default.
{
try{
double
}
catch(int i) { // catch an int
exception
cout << "Caught an integern";
}
catch(...) { // catch all other
exceptions
}
}
int main()
{
cout << "Startn";
Xhandler(0);
Xhandler(1);
Xhandler(2);
cout << "End";
return 0;
//output
Start
Caught an integer
Caught One!
Caught One!
End

Restricting Exceptions
 You can restrict the type of exceptions that a function can
throw outside of itself.
 you can also prevent a function from throwing any
exceptions whatsoever.
 To accomplish these restrictions, you must add a throw
clause to a function definition.
 The general form of this is shown here:
ret-type func-name(arg-list) throw(type-list)
{
// ...
}
 only those data types contained in the comma-separated
type-list may be thrown by the function.

 Throwing any other type of expression will cause
abnormal program
termination.
 If you don't want a function to be able to throw
any exceptions, then use an empty list.
 Attempting to throw an exception that is not
supported by a function will cause the standard
library function unexpected() to be called.
 By default, this causes abort() to be called, which
causes abnormal program termination.

// Restricting function throw types.
// This function can only throw ints,
chars, and doubles.
void Xhandler(int test) throw(int, char,
double)
{
if(test==2) throw 123.23; // throw double
}
int main()
{
cout << "startn";
try{
Xhandler(0); // also, try passing 1 and 2
to Xhandler()
}
catch(int i) {
cout << "Caught an integern";
}
catch(char c)
{
cout << "Caught charn";
}
catch(double d) {
cout << "Caught
doublen";
}
cout << "end";
return 0;
}

Rethrowing an Exception
 We can rethrow exception using throw, by itself,
with no exception. This causes the current
exception to be passed on to an outer try/catch
sequence.
 The most likely reason for doing so is to allow
multiple handlers access to the exception.
 An exception can only be rethrown from within a
catch block (or from any function called from
within that block).
 When you rethrow an exception, it will not be
recaught by the same catch statement. It will
propagate outward to the next catch
statement.28 By:-Gourav Kottawar

void Xhandler()
{
try {
throw "hello"; // throw a
char *
}
catch(const char *) { //
catch a char *
cout << "Caught char *
inside Xhandlern";
throw ; // rethrow char * out
of function
}
}
int main()
{
cout << "Startn";
try{
Xhandler();
}
catch(const char *) {
cout << "Caught char * inside
mainn";
}
cout << "End";
return 0;
}

void Xhandler()
{
try {
throw "hello"; // throw a
char *
}
catch(const char *) { //
catch a char *
cout << "Caught char *
inside Xhandlern";
throw ; // rethrow char * out
of function
}
}
int main()
{
cout << "Startn";
try{
Xhandler();
}
catch(const char *) {
cout << "Caught char * inside
mainn";
}
cout << "End";
return 0;
}//output
Start
Caught char * inside Xhandler
Caught char * inside main
End30 By:-Gourav Kottawar

Understanding terminate( ) and unexpected(
)
 terminate() and unexpected() are called when
something goes wrong during the exception
handling process.
These functions are supplied by the Standard C++
library.
 Their prototypes are shown here:
void terminate( );
void unexpected( );
 These functions require the header <exception>.
 The terminate() function is called whenever the
exception handling subsystem fails to find a
matching catch statement for an exception.
 It is also called if your program attempts to rethrow
an exception when no exception was originally
thrown.

Understanding terminate( ) and unexpected( )
 The terminate() function is also called under
various other, more obscure circumstances.
 In general, terminate() is the handler of last
resort when no other handlers for an exception
are available. By default, terminate() calls
abort() .
 The unexpected() function is called when a
function attempts to throw an exception that is
not allowed by its throw list. By default,
unexpected() calls terminate() .

Setting the Terminate and Unexpected Handlers
 The terminate() and unexpected() functions halt program
 execution when an exception handling error occurs. However,
you can change the functions that are called by terminate()
and unexpected() .
 program to take full control of the exception handling
subsystem.
 To change the terminate handler, use set_terminate()
terminate_handler set_terminate(terminate_handler newhandler)
throw( );
Here newhandler is a pointer to the new terminate handler. The
function returns a
pointer to the old terminate handler.
The new terminate handler must be of type terminate_handler,
which is defined like this:
typedef void (*terminate_handler) ( );

To change the unexpected handler, use
set_unexpected() , shown here:
unexpected_handler
set_unexpected(unexpected_handler newhandler) throw( );
newhandler is a pointer to the new unexpected handler. The
function returns a
pointer to the old unexpected handler. The new unexpected
handler must be of type unexpected_handler, which is
defined like this:
typedef void (*unexpected_handler) ( );
This handler may itself throw an exception, stop the program, or
call terminate() .
However, it must not return to the program.
Both set_terminate() and set_unexpected() require the header
<exception>.

#include <cstdlib>
#include <exception>
void my_Thandler()
{
cout << "Inside new
terminate handlern";
abort();
}
int main()
{
// set a new terminate handler
set_terminate(my_Thandler);
try {
}
catch (double i) { // won't catch
an int exception
// ...
}
return 0;
}

#include <cstdlib>
#include <exception>
void my_Thandler()
{
cout << "Inside new
terminate handlern";
abort();
}
int main()
{
// set a new terminate handler
set_terminate(my_Thandler);
try {
}
catch (double i) { // won't catch
an int exception
// ...
}
return 0;
}
The output from this program
is shown here.
Inside try block
Inside new terminate handler
abnormal program termination36 By:-Gourav Kottawar

The uncaught_exception( ) Function
The C++ exception handling subsystem
supplies one other function that you may
finduseful: uncaught_exception() .
Its prototype is shown here:
bool uncaught_exception( );
This function returns true if an exception has
been thrown but not yet caught.
Once caught, the function returns false.

exception handling in cpp

More Related Content

What's hot (20)

Viewers also liked (13)

Similar to exception handling in cpp (20)

More from gourav kottawar (20)

Recently uploaded (20)

exception handling in cpp