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