UNIVERSITY OF CHAKWAL

DEPARTMENT OF COMPUTER SCIENCE

(Object Oriented Programming)

Lab 13

C++ Exception Handling

Lab Instructor: Engr. Samina Bilquees

Exception Handling
An exception is a problem that arises during the execution of a program. A C++ exception is a response to
an exceptional circumstance that arises while a program is running, such as an attempt to divide by zero.

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.

 throw − A program throws an exception when a problem shows up. This is done using
a throw keyword.
 catch − A program catches an exception with an exception handler at the place in a program where
you want to handle the problem. The catch keyword indicates the catching of an exception.
 try − A try block identifies a block of code for which particular exceptions will be activated. It's
followed by one or more catch blocks.

Assuming a block will raise an exception, a method catches an exception using a combination of
the try and catch keywords. A try/catch block is placed around the code that might generate an exception.
Code within a try/catch block is referred to as protected code, and the syntax for using try/catch as follows

try {
// protected code
} catch( ExceptionName e1 ) {
// catch block
} catch( ExceptionName e2 ) {
// catch block
} catch( ExceptionName eN ) {
// catch block
}
Catching Exceptions
The catch block following the try block catches any exception. You can specify what type of exception
you want to catch and this is determined by the exception declaration that appears in parentheses
following the keyword catch.

try {
// protected code
} catch( ExceptionName e ) {
// code to handle ExceptionName exception
}

Above code will catch an exception of ExceptionName type. If you want to specify that a catch block
should handle any type of exception that is thrown in a try block, you must put an ellipsis, ..., between the
parentheses enclosing the exception declaration as follows −

try {
// protected code
} catch(...) {
// code to handle any exception
}

The following is an example, which throws a division by zero exception and we catch it in catch block.

#include <iostream>
using namespace std;

double division(int a, int b) {

if( b == 0 ) {
throw "Division by zero condition!";
}
return (a/b);
}

int main () {
int x = 50;
int y = 0;
double z = 0;

try {
z = division(x, y);
cout << z << endl;
} catch (const char* msg) {
cerr << msg << endl;
}

return 0;
}

Because we are raising an exception of type const char*, so while catching this exception, we have to use
const char* in catch block. If we compile and run above code, this would produce the following result −

Division by zero condition!

Example of Exception Handling
// program to divide two numbers
// throws an exception when the divisor is 0

#include <iostream>
using namespace std;

int main() {

double numerator, denominator, divide;

cout << "Enter numerator: ";

cin >> numerator;

cout << "Enter denominator: ";

cin >> denominator;

try {

// throw an exception if denominator is 0

if (denominator == 0)
throw 0;

// not executed if denominator is 0

divide = numerator / denominator;
cout << numerator << " / " << denominator << " = " << divide << endl;
}
 catch (int num_exception) {
cout << "Error: Cannot divide by " << num_exception << endl;
}

return 0;
}

Output 1
Enter numerator: 72
Enter denominator: 0
Error: Cannot divide by 0

Output 2
Enter numerator: 72
Enter denominator: 3
72 / 3 = 24

The above program divides two numbers and display the result. But an exception occurs if denominator is
0. TO handle the exception, we have put the code divide=numerator/denominator; inside the try block.
Now when an exception occurs the rest of the code inside the try block is skipped. The catch block
catcheds the thrown exception and executes the statements inside it. If none of statement in try block
generates and exception,the catch block is skipped.

Catching all type of Exceptions

In exception handling it is important that we know the types of excceptions that can occur due to the code
in our try statement. This is so that we can use the appropriate catch parameters. Otherwise the try catch
statements might not work properly. If we do not know the types of exceptions that can occur in our try
block then we can use the ellipsis symbol … as our catch parameter.

try {
// code
}
catch (...) {
// code
}
C++ Multiple catch statements

In C++, we can use multiple catch statements for different kinds of exceptions that can result from a
single block of code.

try {
// code
}
catch (exception1) {
// code
}
catch (exception2) {
// code
}
catch (...) {
// code
}

Here our program catched exception1 if that exception occurs. If not, it will catch exception2 if it occurs.
If there is an error that is neither exception 1 nor exception 2, then the code inside of catch(…) {} is
executed. Notes: catch (…) {} should always be the final block in our try…catch statement. This is the
because this block catches all possible exceptions and acts as the default catch block. It is not compulsory
to include the default block in our code.

Example 2: C++ Multiple Catch Statements

This program divides two numbers and stores the result in an array element. There are two possible
exceptions that can occur in this program:

 If an array is out of bounds i.e. if the index of the array is greater than the size of array.

 If number is divided by 0 These exceptions are catught in multiple statements.

#include <iostream>
using namespace std;

int main() {

double numerator, denominator, arr[4] = {0.0, 0.0, 0.0, 0.0};

int index;

cout << "Enter array index: ";

cin >> index;

try {

// throw exception if array out of bounds

if (index >= 4)
throw "Error: Array out of bounds!";

// not executed if array is out of bounds

cout << "Enter numerator: ";
cin >> numerator;

cout << "Enter denominator: ";

cin >> denominator;

// throw exception if denominator is 0

if (denominator == 0)
throw 0;

// not executed if denominator is 0

arr[index] = numerator / denominator;
cout << arr[index] << endl;
}

// catch "Array out of bounds" exception

catch (const char* msg) {
cout << msg << endl;
}

// catch "Divide by 0" exception

catch (int num) {
cout << "Error: Cannot divide by " << num << endl;
}

// catch any other exception

 catch (...) {
cout << "Unexpected exception!" << endl;
}

return 0;
}

Output 1

Enter array index: 5

Error: Array out of bounds!

Here, the array arr only has 4 elements. So, index cannot be greater than 3.
In this case, index is 5. So we throw a string literal "Error: Array out of bounds!". This exception is
caught by the first catch block.
Notice the catch parameter const char* msg. This indicates that the catch statement takes a string literal
as an argument.

Output 2

Enter array index: 2

Enter numerator: 5
Enter denominator: 0
Error: Cannot divide by 0

Here, the denominator is 0. So we throw the int literal 0. This exception is caught by the
second catch block.
If any other exception occurs, it is caught by the default catch block.

Output 3

Enter array index: 2

Enter numerator: 5
Enter denominator: 2
2.5

Here the program runs without any problem as no exception occurs.

C++ Standard Exceptions
C++ provides a list of standard exceptions defined in <exception> which we can use in our programs.
These are arranged in a parent-child class hierarchy shown below
Here is the small description of each exception mentioned in the above hierarchy
Sr.No Exception & Description

1
std::exception
An exception and parent class of all the standard C++ exceptions.

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 exceptions in a C++ program.

5
std::bad_typeid
This can be thrown by typeid.

6
std::logic_error
An exception that theoretically can be detected by reading the code.

7
std::domain_error
This is an exception thrown when a mathematically invalid domain is 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::vector and
std::bitset<>::operator[]().
11
std::runtime_error
An exception that theoretically cannot be detected by reading the code.

12
std::overflow_error
This is thrown if a mathematical overflow occurs.

13
std::range_error
This is occurred when you try to store a value which is out of range.

14
std::underflow_error
This is thrown if a mathematical underflow occurs.

Define New Exceptions

You can define your own exceptions by inheriting and overriding exception class functionality. Following
is the example, which shows how you can use std::exception class to implement your own exception in
standard way

#include <iostream>
#include <exception>
using namespace std;

struct MyException : public exception {

const char * what () const throw () {
return "C++ Exception";
}
};
int main() {
try {
throw MyException();
} catch(MyException& e) {
std::cout << "MyException caught" << std::endl;
std::cout << e.what() << std::endl;

} catch(std::exception& e) {
 //Other errors
}
}

This would produce the following result −

MyException caught
C++ Exception

Here, what() is a public method provided by exception class and it has been overridden by all the child
exception classes. This returns the cause of an exception.

Lab Tasks
Execute all the codes of exception handling that you have taught in the lecture slides and check that how
exceptions are handled in different ways.