conditions that a program may encounter while executing.
Learners Support Publications www.lsp4you.com
Introduction
• Anomalies includes : – Division by zero – Access to an array outside of its bounds – Running out of memory or disk space
Learners Support Publications www.lsp4you.com
Basics of Exception Handling • The purpose of exception handling mechanism is to provide means to detect and report an exceptional circumstances so that appropriate action can be taken. • Exceptions are of two types: – Synchronous Exception • Out-of-range index • Over-flow – Asynchronous Exception • Keyboard interrupts
Learners Support Publications www.lsp4you.com
Basics of Exception Handling • The mechanism has error handling code that perform the following tasks: – Find the problem ( Hit the exception ) – Inform that an error has occurred ( Throw the exception ) – Receive the error information ( Catch the exception ) – Take corrective actions ( Handle the exception )
Learners Support Publications www.lsp4you.com
Exception Handling Mechanism • C++ exception handling mechanism is basically built upon threeckeywords, namely, try. throw, and catch. The keyword try is used tocpreface a block of statements (surrounded by braces] which may generate exceptions. • This block of statements is known as try block. When an exception is detected, it is thrown using a throw statement in the try block. • A catch block defined by the keyword catch 'catches' the exception 'thrown' by the throw statement in the try block, and handles it appropriately. • The catch block that catches an exception must immediately follow the try block that throws the exception. • The general form of these two blocks are as follows:
Learners Support Publications www.lsp4you.com
• …...... • …...... • try • { • …....... • throw exception; // Block of statements which • …....... // detects and throws an exception • …....... • } • catch(type arg) // Catches exception • { • …........ //Block of statements that • …........ // handles the exception • …........ • } • …........ • …........
Learners Support Publications www.lsp4you.com
• When the try block throws an exception, the program control leaves the try block and enters the catch statement of the catch block. Note that exceptions are objects used to transmit information about a problem. • If the type of object thrown matches the arg 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 the 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. That is, the catch block is skipped.
Learners Support Publications www.lsp4you.com
#include <iostream> catch(int i) // Catches the exception using namespace std; { int main() cout « "Exception caught: x « " « x « "\n"; { } int a,b; cout « "END"; cout « "Enter Values of a and b \n"; return 0; cin » a; } cin » b; The output of Program 13.1: int x = a-b; First Run try Enter Values of a and b { 20 16 if(x != 0) Result (a/x) = 4 { END cout « "Result(a/x) = “ « a/x «“\n”; Second Run } Enter Values of a and b else // There's an exception 10 10 { Exception caught: x = 0 throw(x); // Throws int object END } } Learners Support Publications www.lsp4you.com • Function invoked by try block throwing exception
Learners Support Publications www.lsp4you.com
The general format of code for this kind of catch(type arg) // Catches exception relationship is shown below: { type function(arg list) // Function with …......... exception …......... Handles exception here { …......... …....... } …....... …........... throw(object); // Throws exception …....... …....... } …......... …......... try { …....... …....... invoke function here …....... }
Learners Support Publications www.lsp4you.com
/ Throw point outside the try block int main() #include <iostream> { using namespace std; try void divide(int x, int y, int z) { { cout « "We are inside the try block \n"; cout « "\nWe are inside the function \n"; divide(10,20,30); // Invoke divide() if((x-y) != 0) // It Is OK divided(10, 10,20); // Invoke dlvide() { } int R = z/(x-y); catch(int i) // Catches the exception cout « "Result = " « R « "\n”; { } cout « “Caught the exception \n"; else // There is a problem } { return 0; throw(x-y); // Throw point } } }
Learners Support Publications www.lsp4you.com
• The output of the Program 13.2: We are inside the try block • We are inside the function • Result = -3 • • We are inside the function Caught the exception
Learners Support Publications www.lsp4you.com
Throwing Mechanism • When an exception that is desired to be handled is detected, it is thrown using the throw statement in one of the following forms: • throw(exception); • throw exception; • throw; // used for rethrowing an exception • • The operand object exception may be of any type, including constants. It is also possible to throw objects not intended for error handling. • 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. • Throw point can be in a deeply nested scope within a try block or in a deeply nested function call. In any case, control is transferred to the catch statement
Learners Support Publications www.lsp4you.com
Catching Mechanism • As stated earlier, code for handling exceptions is included in catch blocks. A catch block looks like a function definition and is of the form • catch(type arg) • // Statements for • // managing exceptions } • The type indicates the type of exception that catch block handles. The parameter arg is an optional parameter name. Note that the exception-handling code is placed between two braces. 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. • If the parameter in the catch statement is named, then the parameter can be used in the exception-handling code. After executing the handler, the control goes to the statement immediately following the catch block. • Due to mismatch, if an exception is not caught, abnormal program termination will occur. It is important to note that the catch block is simply skipped if the catch statement does not catch an exception.
Learners Support Publications www.lsp4you.com
Multiple Catch Statements • It is possible that a program segment has more than one condition to throw an exception. In such cases, we can associate more than one catch statement with a try (much like the conditions in a switch statement) as shown below: • try • { • // try block • } • catch(type1 arg) • { • // catch block1 • } • catch(type2 arg) • { • // catch block2 • } • catch(typeN arg) • { • // catch blockN Learners Support Publications www.lsp4you.com • } • When an exception is thrown, the exception handlers are searched in order for an appropriate match. The first handler that yields a match is executed. • After executing the handler, the control goes to the first statement after the last catch block for that try. (In other words, all other handlers are bypassed). When no match is found, the program is terminated. • It is possible that arguments of several catch statements match the type of an exception. In such cases, the first handler that matches the exception type is executed
Learners Support Publications www.lsp4you.com
{ #include <iostrearn> cout« "Caught an integer \n"; using namespace std; } void test(int x) catch(double d) // Catch3 { { try cout< <"Caught a double\n"; { } if(x==1) throw x; int cout<< "End of try-catch system \n\n"; else } If (x==0) throw 'x'; // char int main() else { if(x==-1) throw1.0; // double cout< <"Testing Multiple Catches\n"; cout<< "End of try-block\n"; cout< <"x==1\n"; } test(1); catch(char c) // Catch1 Cout<< "x==0 \n"; { test(0); Cout << "Caught a character \n"; cout<< "x==-1\n"; test(-1); } cout<< "x==2\n"; catch(int m) // Catch 2 test(2); Learners Support Publications www.lsp4you.com return0; #include <iostream> void test(int x) { try { if(x==0)throw x; // int if(x== -1)throw 'x'; //char if(x==1)throw 1.0; // float } catch(...) // catch all { cout<< "Caught an exception\n"; int main() { cout << "Testing Generic Catch \n"; test(-1); test(0); test(1); return0; } Learners Support Publications www.lsp4you.com Rethrowing an Exception • A handler may decide to rethrow the exception caught without processing • it. In such situations, we may simply invoke throw without any arguments • as shown below: • throw; • This causes the current exception to be thrown to the next enclosing • try/catch sequence and is caught by a catch statement listed after that • enclosing try block.
Learners Support Publications www.lsp4you.com
#include <iostream> int main() using namespace std; { void divide(double x, double y) cout « "Inside main \n"; { cout « "Inside function \n"; try try { { divide(10.5,2.0); if(y == 0.0) divide(20.0,0.0); throw y; // Throwing double } else cout « “Division = " « x/y « “\n”; catch(double) } { catch(double) // Catch a double cout « "Caught double inside main { \n”; cout « "Caught double Inside function } \n"; throw; // Rethrowing double cout « “End of main \n”; } return 0; cout « "End of function \n\n"; } } Learners Support Publications www.lsp4you.com • The output of the Program 13.5: • Inside main • Inside function • Division = 5.25 • End of function • Inside function • Caught double inside function • Caught double Inside main • End of main • When an exception is rethrown, it will not be caught by the same catch statement or any other catch in that group. Rather, it will be caught by an appropriate catch in the outer try/catch sequence only. • A catch handler itself may detect and throw an exception. Here again, the exception thrown will not be caught by any catch statements in that group. It will be passed on to the next outer try/catch sequence for processing.
Learners Support Publications www.lsp4you.com
• Specifying Exceptions • It is possible to restrict a function to throw only certain specified exceptions. This is achieved by adding a throw list clause to the function definition. The general form of using an exception specification is: • type function(arg-list) throw (type-list) • { • …....... • …....... Function body • …....... • }
Learners Support Publications www.lsp4you.com
• The type-list specified of exceptions yhat may be thrown.Throwing any other type of exception will cause abnormal program termination.If we wish to prevent a function from throwing any exception, we may do so by making the type-list.That is,we must use • throw(); • In the function header line.
Learners Support Publications www.lsp4you.com
#include <iostream> catch(double d) // Catch3 void test(int x)throw(int,double) { { cout< <"Caught a double\n"; try } { cout<< "End of try-catch system \n\n"; if(x==0)throw x; // char } else int main() if(x== 1)throw 'x'; //int { else cout< <"Testing Multiple Catches\n"; if(x==-1)throw 1.0; // double cout< <"x==1\n"; Cout<<“End of function block \n” test(1); } Cout<< "x==0 \n"; catch(char c) // Catch1 test(0); { cout<< "x==-1\n"; Cout << "Caught a character \n"; test(-1); } cout<< "x==2\n"; catch(int m) // Catch 2 test(2); { return0; cout« "Caught an integer \n"; } } Output Testing Throw Restriction X==0 caught a character Learners Support Publications www.lsp4you.com End of try-catch system Thank You