CMPT 212 Object-Oriented Applications Design in C++ Spring 1998

Read section Function Templates of chapter 8 from C++ Primer Plus (2nd ed.), by Stephen Prata. Read section Class Templates of chapter 13 from C++ Primer Plus (2nd ed.), by Stephen Prata.

Exceptions (continued)

• In a function prototype, we can declare what types of exceptions the function may throw.
  • Example:

       float square_root(float) throw (char *);
       void other_func() throw (int, char *);
       void f() throw ();     // throws no execptions.
    	       

  • Note that if function f calls function g, and g throws an exception which f does not catch, then that exception is also thrown by f.

  • By declaring in the function prototype the types of exceptions thrown, we can see what exceptions may be thrown by functions that we are calling. We can then decide whether we want to catch them or let them be passed up to the function which called our function.

• An exception value can be an object.
  • Example:

       class myException {
          public:
    	 myException(int i) { ... }
    	 void display() { ... }
          ...
          }:
    
       void f() {
          try {
    	 ...
    	 throw myException(3);
    	 ...
    	 }
          catch (myException& e) {
    	 e.display();
    	 }
          ...
       }
    	       

• In a larger program, there may be a hierarchy of classes derived from some base execption class.
  • If we want to catch a specific type of exception, we specify that type in the catch clause:

       catch (derivedException& e) { ... }
    	       

  • We may have this hierarchy of exception classes:

Function Templates

• Suppose we have a function that will swap two ints:

     void swap(int & x, int & y) {
        int temp = x;
        x = y;
        y = temp;
     }
  	 

  • Now suppose we want a function that will swap two chars or two floats or two of something else.

  • Except for the declaration of the parameters and the temp variable, the swap function doesn't care what type it is working with, provided that the type has an assignment operator.

  • Wny can't we write just one swap function that will work with any type (provided that the type has an assignment operator)?

  • Function templates allow us to do this.

• A function template defines an infinite set of overloaded functions.

• Example:

     template <class T>
     void swap(T & x, T & y) {
        T temp = x;
        x = y;
        y = temp;
     }
  	 

  • T is a type parameter. It is a parameter whose value is a type.

  • Like any parameter, we can give it any name. It is common to call it T.

Return to lecture notes index

Lectures