TEMPLATES AND EXCEPTION HANDLING

Transcription

1 CONTENTS: Function template Class template Exception handling Try-Catch-Throw paradigm Exception specification Terminate functions Unexcepted functions Uncaught exception UNIT-III TEMPLATES AND EXCEPTION HANDLING Function Template: The function template that could be used to create a family of functions with different argument types. The general format of a function template is template<class T> returntype functionname(arguments of type T) //.. // Body of function // with type T // wherever appropriate //... The following example declares a swap() function template that will swap two values of a given type of data. template<class T> void swap(t&x, T&y) T temp = x; x = y; y = temp;

2 C++ Template functions - Details: Let us assume a small example for Add function. If the requirement is to use this Add function for both integer and float, then two functions are to be created for each of the data type (overloading). int Add(int a,int b) return a+b; // function Without C++ template float Add(float a, float b) return a+b; // function Without C++ template If there are some more data types to be handled, more functions should be added. But if we use a c++ function template, the whole process is reduced to a single c++ function template. The following will be the code fragment for Add function. template <class T> T Add(T a, T b) //C++ function template sample return a+b; Now when the integer version of the function, the compiler generates an Add function compatible for integer data type and if float is called it generates float type and so on. Here T is the typename. This is dynamically determined by the compiler according to the parameter passed. The keyword class means, the parameter can be of any type. It can even be a class.

3 C++ Template functions - Applicability: C++ function templates can be used wherever the same functionality has to be performed with a number of data types. Though very useful, lots of care should be taken to test the C++ template functions during development. C++ Class template: C++ Class Templates are used where we have multiple copies of code for different data types with the same logic. If a set of functions or classes have the same functionality for different data types, they becomes good candidates for being written as Templates. One good area where this C++ Class Templates are suited can be container classes. Very famous examples for these container classes will be the STL classes like vector, list etc., Once code is written as a C++ class template, it can support all data types. Declaring C++ Class Templates: Declaration of C++ class template should start with the keyword template. A parameter should be included inside angular brackets. The parameter inside the angular brackets, can be either the keyword class or typename. This is followed by the class body declaration with the member data and member functions. The following is the declaration for a sample Queue class. //Sample code for C++ Class Template template <typename T> template <class X>

4 void swapargs(x &a, X &b) X temp temp a=b b = temp A Function with Two Generic Types: You can define more than one generic data type in the template statement by using a comma-separated list. For example, this program creates a template function that has two generic types. #include <iostream> using namespace std; template <class typel, class type2> void myfunc(typel x, type2 y) cout << x << << y ; int main() myfunc(lo, I like C++ ); myfunc(98.6, 19L); return 0; In this example, the placeholder types typel and type2 are replaced by the compiler with the data types int and char, and double and long, respectively, when the compiler generates the specific instances of myfunc( ) within main( ). Overloading a Function Template: In addition to creating explicit, overloaded versions of a generic function, you can also overload the template specification itself.

5 To do so, simply create another version of the template that differs from any others in its parameter list. For example: / / Overload a function template declaration. #include <iostream> using namespace std; // First version of f() template. template <class X> void f(x a) cout << Inside f(x a)\n ; // Second version of f() template. template <class X, class Y> void f(x a, Y b) cout << Inside f(x a, Y b)\n ; int main() f (10) ; // calls f (X) f(lo, 20); // calls f(x, Y) return 0; Here, the template for f() is overloaded to accept either one or two parameters. An Example with Two Generic Data Types: A template class can have more than one generic data type. Simply declare all the data types required by the class in a comma-separated list within the template specification. For example, the following short example creates a class that uses two generic data types. / * This example uses two generic data types in a class definition. #include <iostrearn> using narnespace std;

6 template <class Typel, class Type2> class myclass Typel i; Type2 j; public: myclass(typel a, Type2 b) i = a; j = b; void show() cout << i << << j << \n ; int main() myclass<int, double> obl(lo, 0.23); myclass<char, char > ob2 ( X, Templates add power ); obl show(); // show mt double ob2 show(); // show char char * return 0; This program produces the following output: X Templates add power. The program declares two types of objects. obi uses int and double data. ob2 uses a character and a character pointer. For both cases, the compiler automatically generates the appropriate data and functions to accommodate the way the objects are created. Exception Handling: The purpose of the exception handling mechanism is to provide means to detect and report an exceptional circumstance so that appropriate action can be taken. The mechanism suggests a separate error handling code that performs the following tasks:

7 1. Find 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. C++ exception handling mechanism is basically built upon three keywords namely, 1. try 2. throw 3. catch The keyword try is used to preface 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. try block Detect and throws an exception Exception object try block Catches and handles the exception The block throwing exception

8 The general form of these two blocks are as follows: try throw exception; // Block of statements which // detects and throws an exception catch(type arg) // Catches exception. // Block of statements that. // handles the exception Throw point Function that causes an exception try block Invokes a function that contains an exception catch block Catches and handles the exception

9 Function invoked by try block throwing exception The general format of code for this kind of relationship is shown below: type function(arg list) //Function with exception throw(object); // Throws exception try... Invoke function here catch(type arg) //Catches exception handles exception here 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:

10 throw(exception); throw exception; throw; //used to rethrowing an exception Throw generates the exception specified by exception. If this exception is to be caught, then throw must be executed either from within a try block itself, or from any function called from within the try block (directly or indirectly). If you throw an exception for which there is no applicable catch statement, an abnormal program termination may occur. Throwing an unhandled exception causes the standard library function terminate() to be invoked. By default, terminate() calls abort() to stop your program, but you can specify your own termination handler, as described later in this chapter. Here is a simple example that shows the way C++ exception handling operates. // A simple exception handling example. #include <iostream> using namespace std; int main() cout << start ; try // start a try block cout << Inside try block\n ; throw 100; // throw an error cout << Ihis will not execute ; catch (int i) // catch an error cout << caught an exception ; cout << i ; cout << End ; return 0; This program displays the following output: Start Inside try block

11 Caught an exception -- value is: 100 End Usually, the code within a catch statement attempts to remedy an error by taking appropriate action. If the error can be fixed, execution will continue with the statements following the catch. However, often an error cannot be fixed and a catch block will terminate the program with a call to exit() or aborto.as mentioned, the type of the exception must match the type specified in a catch statement. For example, in the preceding example, if you change the type in the catch statement to double, the exception will not be caught and abnormal termination will occur. Using Multiple catch Statements: As stated, you can have more than one catch associated with a try. In fact, it is common to do so. However, each catch must catch a different type of exception. For example, this program catches both integers and strings. int main() cout << start ; try // start a try block cout << Inside try block\n ; throw 100; // throw an error else throw 10.1 cout << Ihis will not execute ; catch (int i) // catch an error cout << caught an exception ; cout << i ; catch(float j) cout<< caught a float exception ;

12 cout << End ; return 0; Exception Handling Options: There are several additional features to C++ exception handling that make it easier and more convenient to use. These attributes are discussed here. Catching All Exceptions: In some circumstances you will want an exception handler to catch all exceptions instead of just a certain type. This is easy to accomplish. Simply use this form of catch. Catch(...): / / process all exceptions Here, the ellipsis matches any type of data. The following program illustrates catch( ). // This example catches all exceptions. #include <iostream.h> void Xhandler(int test) try if(test==0) throw test; // throw int if(test==l) throw a ; // throw char if(test==2) throw 123,23; // throw double catch(.,.) // catch all exceptions cout << Caught Qne!\n ; int main() cout << start\n ; Xhandler(0) Xhandler(l) Xhandler(2) cout << End ;

13 Rethrowing an Exception: If you wish to rethrow an expression from within an exception handler, you may do so by calling throw, by itself, with no exception. This causes the current exception to be passed on to an outer try/catch sequence. The most likely reason for doing so is to allow multiple handlers access to the exception. For example, perhaps one exception handler manages one aspect of an exception and a second handler copes with another. An exception can only be rethrown from within a catch block (or from any function called from within that block). When you rethrow an exception, it will not be recaught by the same catch statement. It will propagate outward to the next catch statement. The following program illustrates rethrowing an exception, in this case a char * exception. / / Example of rethrowing an exception. #include <iostream> using namespace std; void Xhandler() try throw hello // throw a char * catch(const char *) // catch a char * cout << Caught char * inside Xhandler\n ; throw // rethrow char * out of function int main() cout << start ; try Xhandler() catch(const char *) cout << Caught char * inside rnain\n ; cout << End ; return 0;

14 This program displays this output: Start Caught char * inside Xhandler Caught char * inside main End Exception specifications: When declaring a function we can limit the exception type it might directly or indirectly throw by appending a throw suffix to the function declaration: float myfunction(char param)throw(int); This declares a function called myfunction which takes one agument of type char and returns an element of type float. The only exception that this function might throw is an exception of type int. If it throws an exception with a different type, either directly or indirectly, it cannot be caught by a regular int-type handler. If this throw specifier is left empty with no type, this means the function is not allowed to throw exceptions. Functions with no throw specifier (regular functions) are allowed to throw exceptions with any type: int myfunction(int param)throw(); //no exceptions allowed int myfunction(int param) // all exceptions allowed Understanding terminate( ) and unexpected(): terminate() and unexpected( ) are called when something goes wrong during the exception handling process.

15 These functions are supplied by the Standard C++ library. Their prototypes are shown here: void terminate( ); void unexpected(); These functions require the header <exception>. The terminate( ) function is called whenever the exception handling subsystem fails to find a matching catch statement for an exception. It is also called if your program attempts to rethrow an exception when no exception was originally thrown. The terminate( ) function is also called under various other, more obscure circumstances. For example, such a circumstance could occur when, in the process of unwinding the stack because of an exception, a destructor for an object being destroyed throws an exception. In general, terminate( ) is the handler of last resort when no other handlers for an exception are available. By default, terminate() calls aborto. The unexpected() function is called when a function attempts to throw an exception that is not allowed by its throw list. By default, unexpected( ) calls terminateo. The uncaught_exception() Function: The C++ exception handling subsystem supplies one other function that you may find useful: uncaught_exceptiono. Its prototype is shown here: bool uncaught_exceptions. This function returns true if an exception has been thrown but not yet caught. Once caught, the function returns false.

16 SUMMARY: C++ supports a mechanism known as template to implement the concept of generic programming. Templates allows us to generate a family of classes or a family of functions to handle different data types. Template classes and functions eliminate code duplication for different types and thus make the program development easier and more manageable. Exceptions are peculiar problems that a program may encounter at run times. Exceptions are of two types: Synchronous and asynchronous. C++ provides mechanism for handling synchronous exceptions. An exception is typically caused by a faulty statement in a try block. The statement discovers the error and throws it, which is caught by a catch statement. The catch statement defines a block of statements to handle the exception appropriately. We may also restrict a function to throw only a set of specified exception by adding a throw specification clause to the function definition. IMPORTANT QUESTIONS: PART - A 1. What IS Generic programming? 2. What is Function Template? 3. What is Class Template? 4. What are Exceptions? 5. What is Exception Handling? 6. What are the keywords used in exception handling? 7. What is catch with ellipses? 8. What are unexcepted exceptions? 9. What are uncaught exception? 10. What do you mean by try with multiple catch? 11. What do you mean by rethrowing an exception?

17 PART B 1. What is generic programming? What are its advantages and state some of its Applications? 2. What is Function template? Write a suitable example program. 3. Explain multiple arguments function templates. 4. What is a class template? Explain the syntax of a class template with suitable program. 5. Explain about exception handling. 6. What are Exceptions? What are the differences between synchronous and asynchronous exceptions? 7. Write a program to demonstrate the catching of all exceptions.