Exception Handling

Introduction

 Typical approach to development:

 Write programs assuming things go as planned
 Get "core" working
 Then take care of "exceptional" cases
 C++ exception-handling facilities
 Handle "exceptional" situations
 Mechanism "signals" unusual happening
 Another place in code "deals" with exception
 Introduction to Exception
Handling
 Sometimes the best outcome can be
when nothing unusual happens
 However, the case where exceptional
things happen must also be prepared for
C++ exception handling facilities are
used when the invocation of a method
may cause something exceptional to
occur
 Introduction to Exception
Handling
 C++ library software (or programmer-defined
code) provides a mechanism that signals when
something unusual happens
 This is called throwing an exception
 In another place in the program, the programmer
must provide code that deals with the
exceptional case
 This is called handling the exception
 Types of C++ Exception
There are two types of exceptions in C++:
1. Synchronous: Exceptions that happen when
something goes wrong because of a mistake in the
input data or when the program is not equipped to
handle the current type of data it’s working with,
such as dividing a number by zero.
2. Asynchronous: Exceptions that are beyond the
program’s control, such as disc failure, keyboard
interrupts, etc.
try-throw-catch Mechanism
Syntax of try-catch in C++
 try-throw-catch Mechanism
1. The try keyword represents a block of code that may
throw an exception placed inside the try block.
2. The catch statement represents a block of code that is
executed when a particular exception is thrown from the
try block.
3. When a program encounters a throw statement, then it
immediately terminates the current function and starts
finding a matching catch block to handle the thrown
exception.
Example 1
int main()
{
// try block
try {
int numerator = 10;
int denominator = 0;
int res;
// check if denominator is 0 then throw runtime
// error.
if (denominator == 0) {
throw runtime_error(
"Division by zero not allowed!");
}
// calculate result if no exception occurs
res = numerator / denominator;
//[printing result after division
cout << "Result after division: " << res << endl;
}
// catch block to catch the thrown exception
catch (const exception& e) {
// print the exception
cout << "Exception " << e.what() << endl;
}
return 0;
}
Example 2
int main()
{
int x = -1;
// Some code
cout << "Before try \n";
// try block
try {
cout << "Inside try \n";
if (x < 0) {
// throwing an exception
throw x;
cout << "After throw (Never executed) \n";
}
}
// catch block
catch (int x) {
cout << "Exception Caught \n";
}
cout << "After catch (Will be executed) \n";
return 0;
}
try-throw-catch Mechanism

 When a try block is executed, three

things can happen:
1. No exception is thrown in the try block
– The code in the try block is executed to the
end of the block
– The catch block is skipped
– The execution continues with the code placed
after the catch block
try-throw-catch Mechanism

2. An exception is thrown in the try block

and caught in the catch block
– The rest of the code in the try block is skipped
– Control is transferred to a following catch
block
– The thrown object is plugged in for the catch
block parameter
– The code in the catch block is executed
– The code that follows that catch block is
executed (if any)
try-throw-catch Mechanism

3. An exception is thrown in the try block and there

is no corresponding catch block to handle the
exception
– The rest of the code in the try block is skipped
– The function throws the exception to its calling
function.
– The calling function either catches the exception
using a catch block, or itself throws the
exception.
try block
 Basic method of exception-handling is
try-throw-catch
 Try block:

try
{
Some_Statements
<some code with a throws statement or a function
invocation that might throw an exception>
Some_More_Statements
}

 Contains code for basic algorithm when all

goes smoothly
 A try block must be followed by at least one catch block
throw
 Inside try-block, when something unusual happens:
try
{
Code_To_Try
if (exceptional_happened)
throw object;
More_Code
}

 Keyword throw followed by an object id

 Called "throwing an exception“
 An exception can be thrown outside of a try block.
catch-block
 When something thrown → goes somewhere
 In C++, flow of control goes from try-block to
catch-block
 try-block is "exited" and control passes to catch-block
 Executing catch block called "catching the
exception"
 Exceptions must be "handled" in some
catch block
 There cannot be a catch block without a
preceding try block.
catch-block
 Recall:

catch(int e)
{
cout << e << " donuts, and no milk!\n";
<< " Go buy some milk.\n";
}
 Looks like function definition with
int parameter!
 Not a function, but works similarly
 Throw like "function call"
catch-block Parameter
 Recall: catch(int e)
 "e" called catch-block parameter
 Each catch block can have at most ONE
catch-block parameter
 Does two things:
1. type name specifies what kind of thrown
value the catch-block can catch
2. Provides name for thrown value caught;
can "do things" with value
Multiple Throws and Catches

 try-block typically throws any number of

exception values, of differing types
 Of course only one exception thrown
 Since throw statement ends try-block
 But different types can be thrown
 Each catch block only catches "one type"
 Typical to place many catch-blocks after each
try-block
 C++ Standard Exceptions
std::exception
1
An exception and parent class of all the standard C++ exceptions.

std::bad_alloc
2
This can be thrown by new.
std::bad_cast
3
This can be thrown by dynamic_cast.
std::bad_exception
4 This is useful device to handle unexpected exceptions in a C++
program.
std::bad_typeid
5
This can be thrown by typeid.

std::logic_error
6
An exception that theoretically can be detected by reading the code.
 C++ Standard Exceptions
std::domain_error
7 This is an exception thrown when a mathematically invalid domain is
used.
std::invalid_argument
8
This is thrown due to invalid arguments.
std::length_error
9
This is thrown when a too big std::string is created.

std::out_of_range
10 This can be thrown by the 'at' method, for example a std::vector and
std::bitset<>::operator[]().

std::runtime_error
11 An exception that theoretically cannot be detected by reading the
code.

std::overflow_error
12
This is thrown if a mathematical overflow occurs.
Standard Library exception
classes