Exception Handling in C Testing Notes | EduRev

Testing : Exception Handling in C Testing Notes | EduRev

 Page 1


Software Design Lecture Notes Prof. Stewart Weiss
Exception Handling
Exception Handling in C++
©Stewart Weiss
By now you are supposed to have learned that an exception, in computer science jargon, is an 
event signaled when something “goes wrong” during the execution of a program.  Exceptions 
can be raised by hardware or by software. Dividing by zero
1
, running out of memory, attempting 
to access protected parts of memory, and such are events typically caught by hardware, picked 
up by the operating system, which then deals with the program, usually summarily and swiftly, 
sending it to program heaven
2
.  But software can also raise exceptions if the language run time 
environment supports it. The C++ environment does.
Why do you need to know how to handle exceptions?  Here is some motivation.
1. A large percentage of the C and C++ standard library functions raise exceptions when some 
“exceptional condition” (i.e., error) occurs. The default action taken by the system (meaning 
operating system and runtime environment) is to terminate the program making the offending 
call.  If your program has instead chosen to “handle” the exception, it will not be terminated 
involuntarily.
2. If you have ever written a robust program that handled all possible “exceptional” 
circumstances, such as invalid input, devices not being ready, network connections that timed 
out, and so on, and you did not use exceptions, then you probably resorted to code that either 
set some global error variables and required that all functions inspect these variables before 
proceeding, or you doubled the size of the program with code like
int  func(…)
{
/* … stuff here … */
errcode = do this;
if  (errcode is an error)
return to caller passing the error code up;
continue with normal processing;
errcode = do the other thing;
if (errcode is an error)
return to caller passing the error code up;
continue with normal processing;
/* … more stuff …*/
}
You probably ended up writing more lines of code to handle errors than code that actually 
did the work.  When an error occurs in a function sitting on top of a deep call stack, the error 
has to propagate all the way back to the function that can reasonably recover, which is often 
1
 Although divide-by-zero errors in C++ do not raise exceptions in the math library.
2
 Asynchronous events such as disk interrupts and keyboard interrupts, are not really exceptions, which are by most 
definitions, synchronous events.
1
Page 2


Software Design Lecture Notes Prof. Stewart Weiss
Exception Handling
Exception Handling in C++
©Stewart Weiss
By now you are supposed to have learned that an exception, in computer science jargon, is an 
event signaled when something “goes wrong” during the execution of a program.  Exceptions 
can be raised by hardware or by software. Dividing by zero
1
, running out of memory, attempting 
to access protected parts of memory, and such are events typically caught by hardware, picked 
up by the operating system, which then deals with the program, usually summarily and swiftly, 
sending it to program heaven
2
.  But software can also raise exceptions if the language run time 
environment supports it. The C++ environment does.
Why do you need to know how to handle exceptions?  Here is some motivation.
1. A large percentage of the C and C++ standard library functions raise exceptions when some 
“exceptional condition” (i.e., error) occurs. The default action taken by the system (meaning 
operating system and runtime environment) is to terminate the program making the offending 
call.  If your program has instead chosen to “handle” the exception, it will not be terminated 
involuntarily.
2. If you have ever written a robust program that handled all possible “exceptional” 
circumstances, such as invalid input, devices not being ready, network connections that timed 
out, and so on, and you did not use exceptions, then you probably resorted to code that either 
set some global error variables and required that all functions inspect these variables before 
proceeding, or you doubled the size of the program with code like
int  func(…)
{
/* … stuff here … */
errcode = do this;
if  (errcode is an error)
return to caller passing the error code up;
continue with normal processing;
errcode = do the other thing;
if (errcode is an error)
return to caller passing the error code up;
continue with normal processing;
/* … more stuff …*/
}
You probably ended up writing more lines of code to handle errors than code that actually 
did the work.  When an error occurs in a function sitting on top of a deep call stack, the error 
has to propagate all the way back to the function that can reasonably recover, which is often 
1
 Although divide-by-zero errors in C++ do not raise exceptions in the math library.
2
 Asynchronous events such as disk interrupts and keyboard interrupts, are not really exceptions, which are by most 
definitions, synchronous events.
1
Software Design Lecture Notes Prof. Stewart Weiss
Exception Handling
the main program.  You might have wished there were a way to just break out of the call 
stack immediately, sort of like a goto outside of the current scope (which is usually 
impossible).
3. The C++ exception handling mechanism in its simplest form is relatively easy to learn and 
use, and doing so will make your programs easier to read, easier to develop and maintain, 
and smaller. And knowing this feature of the language will make you a better programmer.
If you have reached this far and are not convinced, you can go back to whatever you were doing 
before you bothered to download these notes. I will assume that anyone who makes it past this 
point is ready for the nitty-gritty.
  
Try-Throw-Catch
These are the three operators that make exception handling work.  throw, try, and catch are 
keywords in C++.  The idea is that you create a try-block, which is a statement block followed 
by exception handlers. An exception handler is introduced by keyword catch. The basic form is
try {
a statement sequence containing function calls to functions 
that might throw exceptions, or to functions that might( call functions
that might call functions that might)*
3
 … throw exceptions
}
catch   ( exception_declaration_1 ) {
statements to handle exceptions of type exception_declaration_1
}
catch  (exception_declaration_2 ) {
statements to handle exceptions of type exception_declaration_2
}
catch  (exception_declaration_3 ) {
statements to handle exceptions of type exception_declaration_3
}
…
catch  (exception_declaration_N ) {
statements to handle exceptions of type exception_declaration_N
}
If an exception is thrown by some function that is called directly or indirectly from within the 
try-block, execution immediately jumps to the first exception handler whose exception 
declaration matches the raised exception.  If there are no handlers that can catch the exception, 
the try-block behaves like an ordinary block, which means it will probably terminate.
An exception declaration is exactly like the formal parameter declaration of a unary function; it 
is a type-specifier optionally followed by a parameter name, such as
catch ( ErrorType1  e)
or
3
 I am using the regular expression operator “*” here to mean “0 or more copies of the preceding string”.
2
Page 3


Software Design Lecture Notes Prof. Stewart Weiss
Exception Handling
Exception Handling in C++
©Stewart Weiss
By now you are supposed to have learned that an exception, in computer science jargon, is an 
event signaled when something “goes wrong” during the execution of a program.  Exceptions 
can be raised by hardware or by software. Dividing by zero
1
, running out of memory, attempting 
to access protected parts of memory, and such are events typically caught by hardware, picked 
up by the operating system, which then deals with the program, usually summarily and swiftly, 
sending it to program heaven
2
.  But software can also raise exceptions if the language run time 
environment supports it. The C++ environment does.
Why do you need to know how to handle exceptions?  Here is some motivation.
1. A large percentage of the C and C++ standard library functions raise exceptions when some 
“exceptional condition” (i.e., error) occurs. The default action taken by the system (meaning 
operating system and runtime environment) is to terminate the program making the offending 
call.  If your program has instead chosen to “handle” the exception, it will not be terminated 
involuntarily.
2. If you have ever written a robust program that handled all possible “exceptional” 
circumstances, such as invalid input, devices not being ready, network connections that timed 
out, and so on, and you did not use exceptions, then you probably resorted to code that either 
set some global error variables and required that all functions inspect these variables before 
proceeding, or you doubled the size of the program with code like
int  func(…)
{
/* … stuff here … */
errcode = do this;
if  (errcode is an error)
return to caller passing the error code up;
continue with normal processing;
errcode = do the other thing;
if (errcode is an error)
return to caller passing the error code up;
continue with normal processing;
/* … more stuff …*/
}
You probably ended up writing more lines of code to handle errors than code that actually 
did the work.  When an error occurs in a function sitting on top of a deep call stack, the error 
has to propagate all the way back to the function that can reasonably recover, which is often 
1
 Although divide-by-zero errors in C++ do not raise exceptions in the math library.
2
 Asynchronous events such as disk interrupts and keyboard interrupts, are not really exceptions, which are by most 
definitions, synchronous events.
1
Software Design Lecture Notes Prof. Stewart Weiss
Exception Handling
the main program.  You might have wished there were a way to just break out of the call 
stack immediately, sort of like a goto outside of the current scope (which is usually 
impossible).
3. The C++ exception handling mechanism in its simplest form is relatively easy to learn and 
use, and doing so will make your programs easier to read, easier to develop and maintain, 
and smaller. And knowing this feature of the language will make you a better programmer.
If you have reached this far and are not convinced, you can go back to whatever you were doing 
before you bothered to download these notes. I will assume that anyone who makes it past this 
point is ready for the nitty-gritty.
  
Try-Throw-Catch
These are the three operators that make exception handling work.  throw, try, and catch are 
keywords in C++.  The idea is that you create a try-block, which is a statement block followed 
by exception handlers. An exception handler is introduced by keyword catch. The basic form is
try {
a statement sequence containing function calls to functions 
that might throw exceptions, or to functions that might( call functions
that might call functions that might)*
3
 … throw exceptions
}
catch   ( exception_declaration_1 ) {
statements to handle exceptions of type exception_declaration_1
}
catch  (exception_declaration_2 ) {
statements to handle exceptions of type exception_declaration_2
}
catch  (exception_declaration_3 ) {
statements to handle exceptions of type exception_declaration_3
}
…
catch  (exception_declaration_N ) {
statements to handle exceptions of type exception_declaration_N
}
If an exception is thrown by some function that is called directly or indirectly from within the 
try-block, execution immediately jumps to the first exception handler whose exception 
declaration matches the raised exception.  If there are no handlers that can catch the exception, 
the try-block behaves like an ordinary block, which means it will probably terminate.
An exception declaration is exactly like the formal parameter declaration of a unary function; it 
is a type-specifier optionally followed by a parameter name, such as
catch ( ErrorType1  e)
or
3
 I am using the regular expression operator “*” here to mean “0 or more copies of the preceding string”.
2
Software Design Lecture Notes Prof. Stewart Weiss
Exception Handling
catch  ( MyOwnError )
An example follows.
struct the_Ball {
int b;
the_Ball(int x = 0) : b(x) { }
};
void test ( )
{
/* … */
throw the_Ball(6);       // This is a throw-statement. It is throwing an anonymous object
// of the_Ball structure, initialized by a call to the constructor
}
int  main ( )
{
/* … stuff here */
try {
test();
}
catch (the_Ball c)
{
cerr << " test() threw ball " << c.b << "\n";
}
…
}
A throw statement is, as shown above, of the form
throw expression;
The thrown expression is any expression that could appear on the right hand side of an 
assignment statement. The most likely candidate is a call to a constructor, such as I showed 
above.  The safest way to handle exceptions is to define unique types for the distinct exceptions. 
One way to guarantee that the types are unique is to enclose them in a namespace. This is also a 
good place for an error count variable.
namespace Error {
int count = 0;
struct the_Towel {  };    // empty struct, default generated constructor
struct the_Game { };    // empty struct 
struct the_Ball {
int b;
the_Ball(int x = 0) : b(x) { }
};
void update()  { count++; }
}
3
Page 4


Software Design Lecture Notes Prof. Stewart Weiss
Exception Handling
Exception Handling in C++
©Stewart Weiss
By now you are supposed to have learned that an exception, in computer science jargon, is an 
event signaled when something “goes wrong” during the execution of a program.  Exceptions 
can be raised by hardware or by software. Dividing by zero
1
, running out of memory, attempting 
to access protected parts of memory, and such are events typically caught by hardware, picked 
up by the operating system, which then deals with the program, usually summarily and swiftly, 
sending it to program heaven
2
.  But software can also raise exceptions if the language run time 
environment supports it. The C++ environment does.
Why do you need to know how to handle exceptions?  Here is some motivation.
1. A large percentage of the C and C++ standard library functions raise exceptions when some 
“exceptional condition” (i.e., error) occurs. The default action taken by the system (meaning 
operating system and runtime environment) is to terminate the program making the offending 
call.  If your program has instead chosen to “handle” the exception, it will not be terminated 
involuntarily.
2. If you have ever written a robust program that handled all possible “exceptional” 
circumstances, such as invalid input, devices not being ready, network connections that timed 
out, and so on, and you did not use exceptions, then you probably resorted to code that either 
set some global error variables and required that all functions inspect these variables before 
proceeding, or you doubled the size of the program with code like
int  func(…)
{
/* … stuff here … */
errcode = do this;
if  (errcode is an error)
return to caller passing the error code up;
continue with normal processing;
errcode = do the other thing;
if (errcode is an error)
return to caller passing the error code up;
continue with normal processing;
/* … more stuff …*/
}
You probably ended up writing more lines of code to handle errors than code that actually 
did the work.  When an error occurs in a function sitting on top of a deep call stack, the error 
has to propagate all the way back to the function that can reasonably recover, which is often 
1
 Although divide-by-zero errors in C++ do not raise exceptions in the math library.
2
 Asynchronous events such as disk interrupts and keyboard interrupts, are not really exceptions, which are by most 
definitions, synchronous events.
1
Software Design Lecture Notes Prof. Stewart Weiss
Exception Handling
the main program.  You might have wished there were a way to just break out of the call 
stack immediately, sort of like a goto outside of the current scope (which is usually 
impossible).
3. The C++ exception handling mechanism in its simplest form is relatively easy to learn and 
use, and doing so will make your programs easier to read, easier to develop and maintain, 
and smaller. And knowing this feature of the language will make you a better programmer.
If you have reached this far and are not convinced, you can go back to whatever you were doing 
before you bothered to download these notes. I will assume that anyone who makes it past this 
point is ready for the nitty-gritty.
  
Try-Throw-Catch
These are the three operators that make exception handling work.  throw, try, and catch are 
keywords in C++.  The idea is that you create a try-block, which is a statement block followed 
by exception handlers. An exception handler is introduced by keyword catch. The basic form is
try {
a statement sequence containing function calls to functions 
that might throw exceptions, or to functions that might( call functions
that might call functions that might)*
3
 … throw exceptions
}
catch   ( exception_declaration_1 ) {
statements to handle exceptions of type exception_declaration_1
}
catch  (exception_declaration_2 ) {
statements to handle exceptions of type exception_declaration_2
}
catch  (exception_declaration_3 ) {
statements to handle exceptions of type exception_declaration_3
}
…
catch  (exception_declaration_N ) {
statements to handle exceptions of type exception_declaration_N
}
If an exception is thrown by some function that is called directly or indirectly from within the 
try-block, execution immediately jumps to the first exception handler whose exception 
declaration matches the raised exception.  If there are no handlers that can catch the exception, 
the try-block behaves like an ordinary block, which means it will probably terminate.
An exception declaration is exactly like the formal parameter declaration of a unary function; it 
is a type-specifier optionally followed by a parameter name, such as
catch ( ErrorType1  e)
or
3
 I am using the regular expression operator “*” here to mean “0 or more copies of the preceding string”.
2
Software Design Lecture Notes Prof. Stewart Weiss
Exception Handling
catch  ( MyOwnError )
An example follows.
struct the_Ball {
int b;
the_Ball(int x = 0) : b(x) { }
};
void test ( )
{
/* … */
throw the_Ball(6);       // This is a throw-statement. It is throwing an anonymous object
// of the_Ball structure, initialized by a call to the constructor
}
int  main ( )
{
/* … stuff here */
try {
test();
}
catch (the_Ball c)
{
cerr << " test() threw ball " << c.b << "\n";
}
…
}
A throw statement is, as shown above, of the form
throw expression;
The thrown expression is any expression that could appear on the right hand side of an 
assignment statement. The most likely candidate is a call to a constructor, such as I showed 
above.  The safest way to handle exceptions is to define unique types for the distinct exceptions. 
One way to guarantee that the types are unique is to enclose them in a namespace. This is also a 
good place for an error count variable.
namespace Error {
int count = 0;
struct the_Towel {  };    // empty struct, default generated constructor
struct the_Game { };    // empty struct 
struct the_Ball {
int b;
the_Ball(int x = 0) : b(x) { }
};
void update()  { count++; }
}
3
Software Design Lecture Notes Prof. Stewart Weiss
Exception Handling
Having defined the above error types,  the program could be
 
void Pitcher ( )
{
/* … */
throw Error::the_Ball(6);
}
void Boxer ( )
{
/* … */
throw Error::the_Towel();
}
void PoorSport ( )
{
/* … */
throw Error::the_Game();
}
int  main ( )
{
/* … stuff here */
try {
Pitcher ( );
Boxer ( );
PoorSport ( );
}
catch (Error::the_Ball c)
{
Error::update();
cerr <<Error::count << ": threw ball " << c.b << "\n";
}
catch (Error::the_Towel )
{
Error::update();
cerr <<Error::count << ": threw in the towel\n";
}
catch (Error::the_Game )
{
Error::update();
cerr << Error::count << ": threw the game\n";
}
…
}
4
Page 5


Software Design Lecture Notes Prof. Stewart Weiss
Exception Handling
Exception Handling in C++
©Stewart Weiss
By now you are supposed to have learned that an exception, in computer science jargon, is an 
event signaled when something “goes wrong” during the execution of a program.  Exceptions 
can be raised by hardware or by software. Dividing by zero
1
, running out of memory, attempting 
to access protected parts of memory, and such are events typically caught by hardware, picked 
up by the operating system, which then deals with the program, usually summarily and swiftly, 
sending it to program heaven
2
.  But software can also raise exceptions if the language run time 
environment supports it. The C++ environment does.
Why do you need to know how to handle exceptions?  Here is some motivation.
1. A large percentage of the C and C++ standard library functions raise exceptions when some 
“exceptional condition” (i.e., error) occurs. The default action taken by the system (meaning 
operating system and runtime environment) is to terminate the program making the offending 
call.  If your program has instead chosen to “handle” the exception, it will not be terminated 
involuntarily.
2. If you have ever written a robust program that handled all possible “exceptional” 
circumstances, such as invalid input, devices not being ready, network connections that timed 
out, and so on, and you did not use exceptions, then you probably resorted to code that either 
set some global error variables and required that all functions inspect these variables before 
proceeding, or you doubled the size of the program with code like
int  func(…)
{
/* … stuff here … */
errcode = do this;
if  (errcode is an error)
return to caller passing the error code up;
continue with normal processing;
errcode = do the other thing;
if (errcode is an error)
return to caller passing the error code up;
continue with normal processing;
/* … more stuff …*/
}
You probably ended up writing more lines of code to handle errors than code that actually 
did the work.  When an error occurs in a function sitting on top of a deep call stack, the error 
has to propagate all the way back to the function that can reasonably recover, which is often 
1
 Although divide-by-zero errors in C++ do not raise exceptions in the math library.
2
 Asynchronous events such as disk interrupts and keyboard interrupts, are not really exceptions, which are by most 
definitions, synchronous events.
1
Software Design Lecture Notes Prof. Stewart Weiss
Exception Handling
the main program.  You might have wished there were a way to just break out of the call 
stack immediately, sort of like a goto outside of the current scope (which is usually 
impossible).
3. The C++ exception handling mechanism in its simplest form is relatively easy to learn and 
use, and doing so will make your programs easier to read, easier to develop and maintain, 
and smaller. And knowing this feature of the language will make you a better programmer.
If you have reached this far and are not convinced, you can go back to whatever you were doing 
before you bothered to download these notes. I will assume that anyone who makes it past this 
point is ready for the nitty-gritty.
  
Try-Throw-Catch
These are the three operators that make exception handling work.  throw, try, and catch are 
keywords in C++.  The idea is that you create a try-block, which is a statement block followed 
by exception handlers. An exception handler is introduced by keyword catch. The basic form is
try {
a statement sequence containing function calls to functions 
that might throw exceptions, or to functions that might( call functions
that might call functions that might)*
3
 … throw exceptions
}
catch   ( exception_declaration_1 ) {
statements to handle exceptions of type exception_declaration_1
}
catch  (exception_declaration_2 ) {
statements to handle exceptions of type exception_declaration_2
}
catch  (exception_declaration_3 ) {
statements to handle exceptions of type exception_declaration_3
}
…
catch  (exception_declaration_N ) {
statements to handle exceptions of type exception_declaration_N
}
If an exception is thrown by some function that is called directly or indirectly from within the 
try-block, execution immediately jumps to the first exception handler whose exception 
declaration matches the raised exception.  If there are no handlers that can catch the exception, 
the try-block behaves like an ordinary block, which means it will probably terminate.
An exception declaration is exactly like the formal parameter declaration of a unary function; it 
is a type-specifier optionally followed by a parameter name, such as
catch ( ErrorType1  e)
or
3
 I am using the regular expression operator “*” here to mean “0 or more copies of the preceding string”.
2
Software Design Lecture Notes Prof. Stewart Weiss
Exception Handling
catch  ( MyOwnError )
An example follows.
struct the_Ball {
int b;
the_Ball(int x = 0) : b(x) { }
};
void test ( )
{
/* … */
throw the_Ball(6);       // This is a throw-statement. It is throwing an anonymous object
// of the_Ball structure, initialized by a call to the constructor
}
int  main ( )
{
/* … stuff here */
try {
test();
}
catch (the_Ball c)
{
cerr << " test() threw ball " << c.b << "\n";
}
…
}
A throw statement is, as shown above, of the form
throw expression;
The thrown expression is any expression that could appear on the right hand side of an 
assignment statement. The most likely candidate is a call to a constructor, such as I showed 
above.  The safest way to handle exceptions is to define unique types for the distinct exceptions. 
One way to guarantee that the types are unique is to enclose them in a namespace. This is also a 
good place for an error count variable.
namespace Error {
int count = 0;
struct the_Towel {  };    // empty struct, default generated constructor
struct the_Game { };    // empty struct 
struct the_Ball {
int b;
the_Ball(int x = 0) : b(x) { }
};
void update()  { count++; }
}
3
Software Design Lecture Notes Prof. Stewart Weiss
Exception Handling
Having defined the above error types,  the program could be
 
void Pitcher ( )
{
/* … */
throw Error::the_Ball(6);
}
void Boxer ( )
{
/* … */
throw Error::the_Towel();
}
void PoorSport ( )
{
/* … */
throw Error::the_Game();
}
int  main ( )
{
/* … stuff here */
try {
Pitcher ( );
Boxer ( );
PoorSport ( );
}
catch (Error::the_Ball c)
{
Error::update();
cerr <<Error::count << ": threw ball " << c.b << "\n";
}
catch (Error::the_Towel )
{
Error::update();
cerr <<Error::count << ": threw in the towel\n";
}
catch (Error::the_Game )
{
Error::update();
cerr << Error::count << ": threw the game\n";
}
…
}
4
Software Design Lecture Notes Prof. Stewart Weiss
Exception Handling
A More Interesting Example (from Stroustrup, pp. 186-187)
struct Range_error {
int i;
Range_error ( int n) { t = n; }
};
char  to_char( int n )
// if n is an integer in the range of valid character codes, return n as a char, 
// otherwise throw a range error.
{
if ( n < numeric_limits<char>::min() || numeric_limits<char>::max() < n )
throw Range_error(n);
return n;
}
void g ( int m)
{
try {
char c = to_char(m);
}
catch (Range_error x) {
cerr << “oops: to_char(“ << x.t << “)\n”;
}
There is a special notation that you can use for the parameter of an exception handler when you 
want it to catch all exceptions.
catch (…)
means catch every exception. It acts like the default case of a switch statement when placed at 
the end of the list of handlers.
This is just a superficial overview of the exception handling mechanism. To give you a feeling 
for why there is much more to learn, consider some of the following complexities.
• Since any type is a valid exception type, suppose it is publicly derived class of a base 
type. Do the handlers catch it if they catch the base type?  What if it is the other way around?
• Can a handler throw an exception? If so, can it throw an exception of the same type as it 
handles? If so, what happens? Does it call itself?  (Fortunately, although the answer is "yes" 
to the first  question, it is "no" to the third.)
• What if the exception is thrown as a reference, but the handler declares it as a const 
parameter?
5
Read More
Offer running on EduRev: Apply code STAYHOME200 to get INR 200 off on our premium plan EduRev Infinity!

Related Searches

ppt

,

Viva Questions

,

Exception Handling in C Testing Notes | EduRev

,

Free

,

Exception Handling in C Testing Notes | EduRev

,

practice quizzes

,

MCQs

,

Exam

,

Objective type Questions

,

past year papers

,

Semester Notes

,

pdf

,

study material

,

Important questions

,

Extra Questions

,

shortcuts and tricks

,

Exception Handling in C Testing Notes | EduRev

,

Summary

,

Sample Paper

,

Previous Year Questions with Solutions

,

mock tests for examination

,

video lectures

;