Exception handling

When the error condition occurs, we want to prevent the further execution of the function. While the library function can easily detect error conditions, it can not decide upon an appropriate handling strategy. Only we can decide what action should be taken whenever a particular error condition is met by the function being called. While the user of the library function can not detect error conditions, it can decide upon an appropriate error handling strategy. Exception handling allows the library to sense and dispatch error conditions and the client to handle

If divide by zero error occurs, the traditional c-style solutions are – (i) terminate the program - abort(); this solution is too extreme and drastic. This solution does not achieve anything tangible. (ii) check the parameters before function call – the application programmer to prevalidate the data before passing them as parameters to the function call. The library function should not burden the user for checking the invalid conditions. (iii) return a value representing an error – does not burden the application program to prevalidate. But allows the application program to take corrective action if it detects an error. These solutions are either too strict or too linient in nature.

C++ offers the mechanism of exception handling to the problem of handling unexpected situations during run time. It uses try, throw and catch blocks. float hmean(const float a, const float b) { if (a== -b) throw “bad arguments to hmean()”; return 2.0 * a * b / (a + b ) ; } void main() { char choice ‘y’ ; double x, y, z ; while (choice ==‘y) { cout<<“enter a number: ” ; cin>> x ; cout<<“enter another number: ” ; cin>> y; try { z = hmean(x, y) ;}

catch ( char * s) { cout << s << endl ; cout << “enter a new pair of numbers\n”; continue ; } cout<<“harmonic mean of”<< x <<“and”<< y <<“is “<<z <<endl ; cout << “continue ? (y / n)”; cin >>choice; } cout << “end”; } This provides a way to transfer control from the library to the application. It has three components: ‘throw’ keyword is used to throw an exception. It is followed by a value, such as character string or an object, indicating the nature of the exception.

The library function notifies the user program about the error by throwing an exception. ‘catch’ is used to catch an exception. It begins with ‘catch’ followed by inside () a type declaration indication the type of exception that it catches. Then by a brace enclosed block of code indicating the actions to take. It is the point to which the control should jump when an exception is thrown. ‘try’ block encloses the block of code that is likely to throw an exception. It consists of calls to library functions that are designed to throw errors. One or more ‘catch’ follow the ‘try’. It is followed by a brace – enclosed block of code with in which exception will be caught.

try { z= hmean ( x, y ) ;} If any statement in the try block causes an exception, ‘catch’ block after this will handle that. if (a== -b) throw “bad arguments to hmean() ”; The ‘throw’ statement resembles return statement It causes the control to back up through the sequence of current function calls until it finds a ‘try’ block. In this case, it passes control back to main(). Then it looks for a matching exception handler. ‘catch’ identifies the handler and the ‘char*s’ meaning that this handler catches a string type exception. The thrown exception is assigned to s. the code with in brace is executed.

If try executes without exceptions, the catch block is skipped and the first statement after the handler is executed. It is necessary to catch exceptions:- The program terminates immediately if an exception thrown by a called function is not caught. It is illegal to have a try block without a catch block. void abc(int x) { if (x<0) throw “invalid parameter”; } Abnormal termination occurs due to uncaught exception with the default error message. If the library programmer creates functions that throw exceptions, the application programmer is

compelled to place the calls to such exception throwing library functions inside try block and to provide suitable catch handlers. The list of exceptions a function throws is indicated in its prototype that is placed in the header file. void abc (int) throw (char *, int ) ; Unwinding of the stack :- The throw statement unwinds the stack, cleaning up all objects declared with in the try block by calling their destructors. Next, throw calls to the matching catch handler, passing the parameter object. Throw destroys all objects from the point of throw until the try block (reversal flow of control).

class A { int x; public : A(int p) {x=p; cout<<“A”<<x<<endl; } ~A() { cout << “A” << x << endl ; } }; void abc () { A A_abc(2); cout<<“calling def”; def(); } void def () { A A_def(3); cout<<“calling ghi”; ghi(); } void ghi () { A A_ghi(4); throw “exception from ghi()”;} Void main() { try { A A_main(1); cout<<“calling abc()”; abc(); } catch (char * s) { cout <<s << endl ; } } Output: A1\ calling abc()\ A2\calling def() \A3\Calling ghi() \A4 \~A4\ ~A3\ ~A2\~A1\exception from ghi()

Need to throw class objects:- the problem with throwing values of fundamental data types is limited. If two or more statements in try block throw values of same type, then conflicts arise and it becomes difficult to detect the source of errorin the catch block. The advantage of throwing objects of classes is that the library programmer can define any number of classes as exception classes. class hmeanexcep { char cError[30]; public: hmeanexcep (char*s) { strcpy(cError,s); } char* getcError() { return cError; } };

class gmeanexcep { char cError[30]; public: gmeanexcep (char class gmeanexcep { char cError[30]; public: gmeanexcep (char*s) { strcpy(cError,s); } char* getcError() { return cError; } }; main() { double x,y,z1,z2; cin>>x>>y; try { z1=hmean(x,y); z2=gmean(x,y); } catch (hmeanexcep & e) { cout << e.getcError() << endl; cout<<“Enter a fresh pair of numbers”; continue; }

catch (gmeanexcep & e) { cout <<e catch (gmeanexcep & e) { cout <<e.getcError()<<endl; cout<<“Enter a fresh pair of numbers”; continue; } cout <<“harmonic mean=“<<z1<<endl; cout <<“geometric mean=“<<z2<<endl; } } double hmean(double a, double b) { if (a=-b) throw hmeanexcep(“Exception error - a = -b not allowed”); return 2.0* a * b / (a+b); } double gmean(double a, double b) {if (a*b<0) throw gmeanexcep(“a*b<0 not allowed”); return sqrt(a * b); }

If we declare the object of the exception class in the catch handler, then the thrown object gets copied in to it. This object can be accessed and used. A temporary copy of the object to be thrown is created and thrown. Catching uncaught exceptions We can catch all types of exceptions that were raised in a try block but not caught by any of the catch blocks. The syntax of the catch for this is catch (…) { //action for handling an exception } This acts like default case in if-else construct. The limitations of exception handling is that if a resource has been aquired and the statements

to release the resource are after the throw statements, then the acquired resource may remain locked up. In order to overcome this problem, classes whose objects function like pointers should be devised. Such objects will have pointers embedded in them. Memory will be allocated dynamically for these pointers during the lifetime of the objects. This memory can be deallocated through destructors. Thus, when the object itself is destroyed, the memory locked up and referenced by the embedded pointer will also be destroyed.

class A { public: A(){ cout<<“constructor”; } ~A(){ cout << “destructor”; } }; void abc (int p) { A* Aptr = newA[2] ; if (p<0) throw “invalid argument to abc()” ; } void main () { try { abc (-1) ; } catch (char *s ) cout << s << endl ; } } output: constructor constructor invalid argument to abc()