 Download Download Presentation Exceptions, Templates, and the Standard Template Library STL

# Exceptions, Templates, and the Standard Template Library STL

Download Presentation ## Exceptions, Templates, and the Standard Template Library STL

- - - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - - -
##### Presentation Transcript

1. Exceptions, Templates, and the Standard Template Library (STL)

2. Exceptions, Templates and STL 2 Exceptions Indicate that something unexpected has occurred or been detected Allow program to deal with the problem in a controlled manner Can be as simple or complex as program design requires The line containing the throw statement is the throw point Control is passed to another part of the program known as the exception handler When an exception is thrown by a function, the function aborts

3. Exceptions, Templates and STL 3 Coding for Exceptions int main() { int numerator={10,0,10}; int denominator= {2,10,0}; double answer; for (int i=0; i<3;i++) { answer = divide(numerator[i], denominator[i]); cout<<numerator[i]<<" divided by "<<denominator[i]<<" = "<<answer<<endl; } cout<<endl<<endl; for (int i=0; i<3;i++) { answer = divide_throw(numerator[i], denominator[i]); cout<<numerator[i]<<" divided by "<<denominator[i]<<" = "<<answer<<endl; } return 0; }

4. Exceptions, Templates and STL 4 Coding for Exceptions double divide(int n, int d) { if (d==0) { cout<<"ERROR: Cannot divide by zero "; return 0; } else return static_cast<double>(n)/d; } double divide_throw(int n, int d) { if (d==0) { throw "ERROR: Cannot divide by zero\n"; } else return static_cast<double>(n)/d; }

5. Exceptions, Templates and STL 5 Coding for Exceptions - Output Output from function divide 10 divided by 2 = 5 0 divided by 10 = 0 ERROR: Cannot divide by zero 10 divided by 0 = 0 Output from function divide_throw 10 divided by 2 = 5 0 divided by 10 = 0 This application has requested the Runtime to terminate it in an unusual way. Please contact the application's support team for more information.

6. Exceptions, Templates and STL 6 Exceptions - Terminology Exception: object or value that signals an error Throw an exception: send a signal that an error has occurred throw � followed by an argument, is used to throw an exception Catch/Handle an exception: process the exception; interpret the signal try � followed by a block { }, is used to invoke code that throws an exception catch � followed by a block { }, is used to detect and process exceptions thrown in preceding try block. Takes a parameter that matches the type thrown.

7. Exceptions, Templates and STL 7 Exceptions � Flow of Control A function that throws an exception is called from within a try block If the function throws an exception, the function terminates and the try block is immediately exited. A catch block to process the exception is searched for in the source code immediately following the try block. If a catch block is found that matches the exception thrown, it is executed. If no catch block that matches the exception is found, the program terminates.

8. Exceptions, Templates and STL 8

9. Exceptions, Templates and STL 9

10. Exceptions, Templates and STL 10

11. Exceptions, Templates and STL 11

12. Exceptions, Templates and STL 12 Catch Exception and Reprompt int main() { int num1, num2; // To hold two numbers double quotient; // To hold the quotient of the numbers bool goodResult; //test if no exception thrown do{ cout << "Enter two numbers: "; cin >> num1 >> num2; goodResult=true; try { quotient = divide(num1, num2); cout << "The quotient is " << quotient << endl; } catch (char *exceptionString) { goodResult=false; cout <<exceptionString; } } while (!goodResult); cout << "End of the program.\n"; return 0; }

13. Exceptions, Templates and STL 13 Exceptions - Notes An integer can be thrown to signal a predefined error code try { quotient = divide(num1, num2); cout << "The quotient is " << quotient << endl; } catch (int exceptionInt) { goodResult=false; cout <<�Error code�<<exceptionInt; } In the function write: if (denominator == 0) throw 333; and then look up the code in a library or table

14. Exceptions, Templates and STL 14 Exceptions - Notes Predefined functions such as new may throw exceptions The value that is thrown does not need to be used in catch block. in this case, no name is needed in catch parameter definition catch block parameter definition does need the type of exception being caught

15. Exceptions, Templates and STL 15 Exception Not Caught? An exception will not be caught if it is thrown from outside of a try block or, there is no catch block that matches the data type of the thrown exception If an exception is not caught, the program will terminate

16. Exceptions, Templates and STL 16 Exceptions and Objects An exception class can be defined in a class and thrown as an exception by a member function An exception class may have: no members: used only to signal an error members: pass error data to catch block A class can have more than one exception class

17. Exceptions, Templates and STL 17

18. Exceptions, Templates and STL 18

19. Exceptions, Templates and STL 19

20. Exceptions, Templates and STL 20

21. Exceptions, Templates and STL 21 Handling Multiple Exceptions To differentiate between a negative width and length, two classes can be created and each called based on the type of error In Rectangle.h include: public: class NegativeWidth { }; // Exception class for a negative width class NegativeLength { }; // Exception class for a negative length and in main change the try blocks to the following: try { myRectangle.setWidth(width); myRectangle.setLength(length); cout << "The area of the rectangle is � << myRectangle.getArea() << endl; } catch (Rectangle::NegativeWidth) { cout<<"Error: A negative value was given "<< "for the rectangle's width.\n"; } catch (Rectangle::NegativeLength) { cout<<"Error:A negative value was given "<< "for the rectangle's length.\n"; }

22. Exceptions, Templates and STL 22 Recovering From Exceptions Within the catch block, prompt the user to re-enter the correct length or width

23. Exceptions, Templates and STL 23 Recovering From Exceptions

24. Exceptions, Templates and STL 24 Extracting Data from the Exception Class Sometimes, we want an exception object to pass data back to the exception handler We want the Rectangle class not only to signal when a negative value was entered, but to pass back that value as well This can be accomplished by expanding the exception class with members in which data can be stored. For example:

25. Exceptions, Templates and STL 25 What Happens After catch Block? Once an exception is thrown, the program cannot return to throw point. The function executing throw terminates (does not return), other calling functions in try block terminate, resulting in unwinding the stack If an exception is thrown by the member function of a class object, then the class destructor is called If objects were created in the try block and an exception is thrown, they are destroyed.

26. Exceptions, Templates and STL 26 Nested try Blocks try/catch blocks can occur within an enclosing try block Exceptions caught at an inner level can be passed up to a catch block at an outer level: catch ( ) { ... throw; // pass exception up } // to next level

27. Exceptions, Templates and STL 27 Nested try Blocks #include <iostream> using namespace std; void doA(); void doB(); int main() { char *exception1; try{ doA(); } catch(char *exception1) { cout<<"Exception 1 handled in main"<<endl; } return 0; }

28. Exceptions, Templates and STL 28 Handling the bad_alloc Exception When the new operator is unable to allocate the requested amount of memory, a bad_alloc exception is thrown. It can be handled as follows: #include <iostream> #include <new> // Needed for bad_alloc using namespace std; int main() { double *ptr; // Pointer to double try { ptr = new double ; } catch (bad_alloc) { cout << "Insufficient memory.\n"; } return 0; }

29. Exceptions, Templates and STL 29 Function Templates Function template: a generic function that can work with any data type. It is a template and by itself does not cause memory to be used An actual instance of the function is created in memory when the compiler encounters a call to the template function The programmer writes the specifications of the function, but substitutes parameters for data types When called, compiler generates code for specific data types in function call

30. Exceptions, Templates and STL 30 Function Template Example template <class T> T square(T num) { return num * num; }

31. Exceptions, Templates and STL 31 Function Template Example template <class T> T square(T num) { return num * num; } Call a template function in the usual manner: int ival = 3; double dval = 12.5; cout << sqaure(ival); // displays 9 cout << sqaure(dval); // displays 156.25

32. Exceptions, Templates and STL 32 Function Template Swap Example #include <iostream> using namespace std; template <class T> void swapVars(T &var1, T &var2) { T temp; temp = var1; var1 = var2; var2 = temp; }

33. Exceptions, Templates and STL 33 Function Template Swap Example int main() { char firstChar, secondChar; // Two chars int firstInt, secondInt; // Two ints double firstDouble, secondDouble; // Two doubles // Get and swapVars two chars cout << "Enter two characters: "; cin >> firstChar >> secondChar; swapVars(firstChar, secondChar); cout << firstChar << " " << secondChar << endl; // Get and swapVars two ints cout << "Enter two integers: "; cin >> firstInt >> secondInt; swapVars(firstInt, secondInt); cout << firstInt << " " << secondInt << endl; // Get and swapVars two doubles cout << "Enter two floating-point numbers: "; cin >> firstDouble >> secondDouble; swapVars(firstDouble, secondDouble); cout << firstDouble << " " << secondDouble << endl; return 0; }

34. Exceptions, Templates and STL 34 Function Template Notes Can define a template to use multiple data types: template<class T1, class T2> Example: template<class T1, class T2> // T1 and T2 will be replaced in the called function //with the data types of the arguments double mpg(T1 miles, T2 gallons) {return miles / gallons}

35. Exceptions, Templates and STL 35 Function Template Notes #include <iostream> using namespace std; template <class T1, class T2> int largest(const T1 &var1, T2 &var2) { if (sizeof(var1) > sizeof(var2)) return sizeof(var1); else return sizeof(var2); } int main() { int i = 0; char c = ' '; float f = 0.0; double d = 0.0; cout << "Comparing an int and a double, the largest\n" << "of the two is " << largest(i, d) << " bytes.\n"; cout << "Comparing an char and a float, the largest\n" << "of the two is " << largest(c, f) << " bytes.\n"; return 0; }

36. Exceptions, Templates and STL 36 Function Template Notes Function templates can be overloaded Each template must have a unique parameter list template <class T> T sum(T val1, T val2) {return val1 + val2} template <class T> T sum(T val1, T val2, Tval3) {return val1 + val2 + val3}

37. Exceptions, Templates and STL 37 Defining Your Own Templates Templates are often appropriate for multiple functions that perform the same task with different parameter data types Develop function using usual data types first, then convert to a template: add template prefix template <class T> convert data type names in the function to a type parameter (i.e., a T type) in the template

38. Exceptions, Templates and STL 38 Class Templates Classes can also be represented by templates. When a class object is created, type information is supplied to define the type of data members of the class. Unlike functions, classes are instantiated by supplying the type name (int, double, string, etc.) at object definition

39. Exceptions, Templates and STL 39 Class Template Example template <class T> class grade { private: T score; public: grade(T); void setGrade(T); T getGrade() };

40. Exceptions, Templates and STL 40 Class Template Example Pass type information to class template when defining objects: grade<int> testList; grade<double> quizList; Use as ordinary objects once defined

41. Exceptions, Templates and STL 41 #include <iostream> using namespace std; template <class T> class Grade { private: T score; public: Grade(T); void setGrade(T); T getGrade(); }; template <class T> Grade<T>::Grade(T s) { score = s; } template <class T> void Grade<T>:: setGrade(T s) { score = s; } template <class T> T Grade<T>:: getGrade() { return score; }

42. Exceptions, Templates and STL 42 Class Templates and Inheritance Class templates can inherit from other class templates: template <class T> class Rectangle { ... }; template <class T> class Square : public Rectangle<T> { ... }; Must use type parameter T everywhere base class name is used in derived class

43. Exceptions, Templates and STL 43 Introduction to the Standard Template Library Standard Template Library (STL): a library containing templates for frequently used data structures and algorithms Not supported by many older compilers

44. Exceptions, Templates and STL 44 Standard Template Library Two important types of data structures in the STL: containers: classes that stores data and imposes some organization on it iterators: like pointers; mechanisms for accessing elements in a container

45. Exceptions, Templates and STL 45 Containers Two types of container classes in STL: sequence containers: organize and access data sequentially, as in an array. These include vector, deque, and list vector � efficiently inserts values to its end, insertions at other points is not as efficient deque � efficiently inserts values to its front and end, not as efficient at inserting at other points list � efficiently inserts values anywhere; doesn�t provide random access associative containers: use keys to allow data elements to be quickly accessed. These include set, multiset, map, and multimap

46. Exceptions, Templates and STL 46 Containers associative containers: use keys to allow data elements to be quickly accessed. These include set, multiset, map, and multimap set � stores a set of keys, no duplicates multiset � stores a set of keys, duplicates allowed map � map a set of keys to data elements; only one key per data, no duplicates multimap - map a set of keys to data elements; many keys per data element are allowed, duplicates are allowed

47. Exceptions, Templates and STL 47 Iterators Generalization of pointers, used to access information in containers Four types: forward (uses ++) bidirectional (uses ++ and -- ) random-access input (can be used with cin and istream objects) output (can be used with cout and ostream objects) vectors and deques require random access iterators; lists, sets, multisets, maps and multimaps require bidirectional iterators

48. Exceptions, Templates and STL 48 Algorithms STL contains algorithms implemented as function templates to perform operations on containers. Requires algorithm header file algorithm includes

49. Exceptions, Templates and STL 49 STL Example // A simple demonstration of STL algorithms #include <iostream> #include <vector> // Required for the vector type #include <algorithm> // Required for STL algorithms using namespace std; int main() { int count; // Loop counter // Define a vector object. vector<int> vect; // Use push_back to push values into the vector. for (count = 0; count < 10; count++) vect.push_back(count); // Display the vector's elements. cout << "The vector has " << vect.size() << " elements. Here they are:\n"; for (count = 0; count < vect.size(); count++) cout << vect[count] << " "; cout << endl;

50. Exceptions, Templates and STL 50 STL Example

51. Exceptions, Templates and STL 51 STL Example - Output