C++ Exception Handling

In this Tutorial we will understand the mechanism of Exception Handling in C++ Programming Language.

Exception Handling in C++

An exception is an unexpected problem that arises during the execution of a program. Exception handling mechanism provide a way to transfer control from one part of a program to another. This makes it easy to separate the error handling code from the code written to handle the actual functionality of the program.
C++ exception handling is built upon three keywords: try, catch, and throw.

try : A block of code which may cause an exception is typically placed inside the try block. It’s followed by one or more catch blocks. If an exception occurs, it is thrown from the try block.
catch : this block catches the exception thrown from the try block. Code to handle the exception is written inside this catch block.
throw : A program throws an exception when a problem shows up. This is done using a throw keyword.

Every try catch should have a corresponding catch block. A single try block can have multiple catch blocks.

try
{
// protected code
}catch( ExceptionName e1 )
{
// catch block
}catch( ExceptionName e2 )
{
// catch block
}catch( ExceptionName eN )
{
// catch block
}

Throwing Exceptions

Exceptions can be thrown anywhere within a code block using throw statements. The operand of the throw statements determines a type for the exception and can be any expression and the type of the result of the expression determines the type of exception thrown.

Following is an example of throwing an exception when dividing by zero condition occurs:

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

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
}

Exception Handling Sample Program

Run Online

#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;
}

Output

Division by zero condition!

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 as given in the output box above.

C++ Standard Exceptions

C++ provides a list of standard exceptions defined in <exception> which we can use in our programs.
Small Description of exceptions is given in the table as follows:

Exception	Description
std::exception	An exception and parent class of all the standard C++ exceptions.
std::bad_alloc	This can be thrown by new.
std::bad_cast	This can be thrown by dynamic_cast.
std::bad_exception	This is useful device to handle unexpected exceptions in a C++ program
std::bad_typeid	This can be thrown by typeid.
std::logic_error	An exception that theoretically can be detected by reading the code.
std::domain_error	This is an exception thrown when a mathematically invalid domain is used
std::invalid_argument	This is thrown due to invalid arguments.
std::length_error	This is thrown when a too big std::string is created
std::out_of_range	This can be thrown by the at method from for example a std::vector and std::bitset<>::operator[]().
std::runtime_error	An exception that theoretically can not be detected by reading the code.
std::overflow_error	This is thrown if a mathematical overflow occurs.
std::range_error	This is ocurred when you try to store a value which is out of range.
std::underflow_error	This is thrown if a mathematical underflow occurs.