Tuesday, January 20, 2015

Exception Handling

Posted By: BackBenchers World - Tuesday, January 20, 2015
An Exception is a condition that is caused by a run-time error in the program. There are two types of bugs which are: Logical Errors and Syntax errors
  •  Logical errors occur due to poor understanding of problem and the solution procedure.
  • Syntax errors occur due to poor understanding of the language itself.


The purpose of exception handling is to provide a means to detect and report "Exception Circumstances" so that appropriate action can be taken.

The mechanism incorporates a separate error handling code that performs the following tasks:
  1. Finding the problem (Hit the exception)
  2. Inform that an error has occurred (Throw the exception)
  3. Receive the error information (Catch the exception)
  4. Take corrective actions (Handle the exception)


Basically there are of two types exceptions

  • Synchronous Exceptions are the errors such as "Out-of-range index", "Overflow".
  • Asynchronous Exceptions are errors that are caused by events beyond the control of the program.

 The Error handling Code consists of two segments:
  • One to detect errors and throw the eception
  • Other to catch the exception and take appropriate actions


Syntax for error handling Code:

Try Block
Detects and throws an exception

  Exception Object

Catch Block
Catches and handles an exception


Exception handling is build upon three keywords
  • try
  • throw
  • catch
Try: It is used to preface a block of statements that causes an error condition and "throws" an exception.

Throw: When an exception is detected, it is thrown using throw statement in the try block.

Catch: Catch block is defined by the keyword catch. It catches the exception thrown by the try block and handles it appropriately.

E.g.:
-------------
-------------
try
{
                statements;       //generates an exception
}

catch(exception_type arg)
{
                statements;       //processes an exception
}
The try block can have one or more statements that could generate an exception.

The catch block can have one or more statments that are necessary to process the exception.

If the try block throws an exception and it matches with the exception type in the catch statement, then catch block is executed for handling the exception.

If they do not match, the program is aborted with the help of abort() function which is invoked by default.

When no exception is detected and thrown, the control goes to the statement immediately after the catch block i.e., the catch block is skipped.

E.g.: Try Block throwing an exception
int main()
{
                int a, b;
                cout<<"Enter the values of a and b\n";
               
                cin>>a>>b;

                int x=a-b;

                try
                {
                                if(x!=0)
                                {
                                                cout<<"Result (a/x) = "<<a/x;
                                }

                                else                                                        //There is an exception
                                {
                                                throw(x);                             //Throws int object
                                }

                                catch(int i)
                                {
                                                cout<<"Exception Caught : x = "<<x;
                                }
                }
                cout<<"\nEnd";
                return0;
}

Output

First Run                                                                                                       Second Run
Enter the values of a and b
20
20
Exception Caught : x = 0
End


Enter the values of a and b
20
15
Result (a/x) = 4
End
This program detects and catches a division-by-zero problem. The output of first run shows a successful execution. When no exception is thrown, the catch block is skipped and execution resumes with the first line after the catch. But in the seond run, the denominator x becomes zero and therefore, division by zero situation occurs. This exception is thrown by using object x.


Functions Invoking Exceptions
Exceptions are thrown by functions that are invoked from within the try block. The point which at which throw is executed is called the Throw Point. Once an exception is thrown to the catch block, control can not return to the throw point.


Throwing Mechanism 
When an exception that is desired to be handled is detected, it is thrown using the throw statement in on of the following form:

throw(exception);
OR
throw exception;
OR
throw; //used for re-throwing an exception

When an exception is thrown, it will be caught by the catch statement associated with the try block. That is the control exits the current try block and is transferred to the catch block after that try block.


Catch Mechanism 
The code for handling exceptions is included in catch blocks

Syntax:
catch(type arg)
{
                //statements for managing exceptions
}

Here type indicates the type of exception that this catch block handles. The perameter arg is an optional parameter name.

The catch statement catches an exception whose type matches with the type of catch argument. When it is caught, the code in the catch block is executed.


Multiple Catch Statments
 When a program has more than one condition to throw an exception, multiple catch statements with a try block is used.

Syntax:
E.g.:
try
                {
                                //try block
                }

                catch(type 1 arg)
                {
                                //catch block 1
                }

                catch(type 2 arg)
                {
                                //catch block 2
                }
                ----------------------
                ----------------------          
                catch(type N arg)
                {
                                //catch block N
                }
void test(int x)
{
                try
                {
                            if(x==1) throw x;              //int
                            if(x==0) throw 'x'             //char
                            if(x==-1) throw x              //double
               
                cout<<"\nEnd of try block";
                }

                catch(char c)                      //catch 1
                {
                            cout<<"\nCought a character\n\n";
                }

                catch(int m)                        //catch 2
                {
                            cout<<"\nCought a integer\n\n";
                }

                catch(double d)                  //catch 3
                {
                            cout<<"\nCought a double\n\n";
                }

                cout<<"\nEnd of try-catch system";
}

int main()
{
                cout<<"Testing multiple catches\n\n";

                cout<<"x==1";
                test(1);
               
                cout<<"x==0";
                test(0);

                cout<<"x==-1";
                test(-1);

                cout<<"x==2";
                test(2);

                return 0;
}

When an exception is thrown, the exception handlers are searched in an order for an appropriate match. After executing with the match handler, the control goes to the first statement after last catch block for that try.

Output
Testing multiple catches

x==1
Cought a character

x==0
Cought a integer

x==-1
Cought a double

x==2
End of try block
End of try-catch system

When try block does not throw any exception and it completes normal execution, control passes to the first statement after the last catch handler.


Catching All Exceptions
It is not possible to determine all possible type of exceptions and therefore no independent catch handler can be designed to catch them.

Syntax:
E.g.: Catch All Exceptions
catch(....)
{
       //statements for processing all exception
}


void test(int x)
                {
                                try
                                {
                                  if(x==1) throw x;              //int
                                  if(x==0) throw 'x';            //char
                                  if(x==-1) throw x;            //double
                                }

                                catch(....)                        //Catch all
                                {
                                  cout<<"Caught an Exception\n";
                                }
                }

                int main()
                {
                                cout<<"Testing Generic Catch\n;
                               
                                test(-1);
                                test(0);
                                test(1);

                                return 0;
                }

Output
Here all throws are caught by the catch(....) statement
Testing Generic Catch
Caught an Exception
Caught an Exception
Caught an Exception

Re-throwing an Exception
When the catch block throws an exception, it is termed as re-throwing an Exception. In such a case, throw is invoked without any argument.

Syntax:                                                   throw;

This causes the current exception to be thrown to the next enclosing try-catch sequence and is caught by the catch statement listed after that enclosing try block.

A catch handler itself may detect and throw an exception. The exception thrown will not be caught by any catch statement of that group. It will be passed to the next outer try-catch sequence for processing.

E.g.:
void divide(double x, double y)
                {
                                cout<<"Inside function";

                                try
                                {
                                                if(y==0.0) throw y;

                                                else cout<<"\nDivision = "<<x/y;
                                }

                                catch(double)
                                {
                                                cout<<"\nCaught double inside function";
                                                throw;
                                }
                                               
                cout<<"\nEnd of function\n\n";
                }

                int mian()
                {
                                cout<<"Inside main\n";

                                try
                                {
                                                divide(10.5, 2.0);
                                                divide(20.0,0.0);
                                }

                                catch(double)
                                {
                                                cout<<"\nCaught double inside main";
                                }
               
                cout<<"\nEnd of main;
                return 0;
                }

Output
Inside main
Inside function
Division = 5.25
End of function

Inside function
Caught double inside function
Caught double inside main
End of main

Specifying Exceptions
It is done to restrict a function to throw only certain specified exception. This is achieved by adding a throw list clause to the function definition.

General form of using Exception Specification:
type function(arg-list) throw (type-list)
{
                --------------
                -------------- function body
                --------------
}

Here type-list specifies the type of exceptions that may be thrown. Throwing any other type of exception will cause abnormal program termination.

To prevent function from throwing any exception the type-list is kept empty. E.g.: throw();.

E.g.:
Output
void test( int x) throw( int, double)
                {
                 if(x==1)              throw x;                //int
                 else if(x==-1)     throw 1.0             //double
               
                cout<<"\nEnd of function block";
                }

int main()
{
                try
                {
                             cout<<"Testing throw restrictions\n\n";

                                cout<<"x==1";
                                test(1);

                                cout<<"x==-1";
                                test(-1);

                                cout<<"x==2";
                                test(2);
                }

                catch(int m)
                {
                                cout<<"\nCaught an integer\n\n";
                }

                catch(double d)
                {
                                cout<<"\nCaught an double\n\n";
                }             
Testing throw restrictions

x==1
Caught an integer

x==-1
Caught an double

x==2
End of function block

Copyright © 2013 TechDotHunter™ is a registered trademark.

Designed by Templateism. Hosted on Blogger Platform.