Exceptions Handling in C++

Exceptions are C++’s means of separating error reporting from error handling.

-Bjarne Stroustrup.

• Exception Handling is a built in mechanism provided by C++.

• If a runtime error (i.e. Exception) is not handled properly then the whole program may crash.

• We use try, catch and throw keywords for exception handling.

• C++ standard library provides a list of standard exceptions in <exception> header.

try, throw:

Whenever a problem occurs an exception is thrown using throw keyword.

This is done by enclosing the exception causing portion of code inside a try block.

Example:

                 try

                 {

      //statements

      if(condition)

                         throw 2;

                 }

try, throw example:

const int DivideByZero = 10;

//....

double divide(double x, double y)

{

try{

if(y==0)

    throw DivideByZero;

}

return x/y;

}

• Divide function does division of two numbers

• If the second number (y) is zero then it throws a DivideByZero exception.

• If you wish to have your program check for exceptions, you must enclose the code that may have exceptions thrown in a try block.

• Whenever an exception is thrown, the corresponding try block terminates

catch:

• catch keyword indicates that the exception that was thrown from the try block is being caught and the code to handle that exception is written inside.

• Catch block should appear immediately after the try block.

• For any try block, there could be multiple catch blocks.

catch(char *s)

{

cout<<s;

}

Multiple catch blocks:

Most of the time, a typical program will throw different types of errors. The C++ language allows you to include different catch blocks. Each catch block can face a specific error. The syntax used is:

try {

Code to Try

}

catch(Arg1)

{

One Exception

}

catch(Arg2)

{

Another Exception

}

Standard Exceptions:

The C++ Standard library provides a base class specifically designed to declare objects to be thrown as exceptions. It is called exception and is defined in the <exception> header file under the namespace std.

All exceptions thrown by components of the C++ Standard library throw exceptions derived from this std::exception class. These are:

exception	description
bad_alloc	thrown by new on allocation failure
bad_exception	thrown when an exception type doesn't match any catch
bad_typeid	thrown by typeid

 

Example:
	#include <iostream> using namespace std; template <class T> T max (T &a, T &b) {    return (a > b)? a : b; } template <> int max <int> (int &a, int &b) {    cout << "Inside specialized template ";    return (a > b)? a : b; } int main () {    int a = 5, b = 10;    cout << max <int> (a, b); }