CMPT 212 Object-Oriented Applications Design in C++ Fall 1997

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.

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.

• To use a specific version of a function template, we just call it.
  • The compiler figures out what types the type parameters should have, and generates the appropriate funciton.

• Example:

     int main() {
        int      a = 3;
        int      b = 7;
        float    f = 3.14;
        float    g = 2.32;
        myObject r;
        myObject s;
  
        swap(a, b);
        swap(f, g);
        swap(r, s);   // provided that "myObject" class 
  		    // has an assignment operator.
  
        return 0;
     }
  	 

• Problem: If our program has some non-template swap functions defined and a swap function template, how does the compiler decide which swap to use?
  • The answer is fairly compilicated, and the new proposed standard for C++ may change it.

Class Templates

• Suppose we have a class that represents an element in a linked list of persons.

     class elem {
        public:
  	 elem * next;
  	 person p;
     };
  
     class list {
        public:
  	 void addToEnd(person & p);
  	 person * getFirst();
  	 person * getNext();
  	 ...
        private:
  	 elem * head;
  	 elem * curr;
     };
  	 

  • Now suppose we want a linked list of some other type, say elephant.

  • How similar would the code for the elephant linked list be to the person linked list code?

  • Except for the declaration of elem and the parameter and return types of some functions, they would be almost identical.

  • The linked list code does not use any property of a person, so we could easily change the list so that it stored elephants.

  • Class templates allow us to do this.

• Example:

     template <class T>
     class elem {
        public:
  	 elem * next;
  	 T      p;
     };
  
     template <class T>
     class list {
        public:
  	 void addToEnd(T & p);
  	 T * getFirst();
  	 T * getNext();
  	 ...
        private:
  	 elem<T> * head;
  	 elem<T> * curr;
     };
  	 

• We can declare different kinds of lists:

     int main() {
        list<person>   list1;
        list<elephant> list2;
        list<char>     list3;
        person         p;
        elephant       e;
        ...
        list1.addToEnd(p);
        list2.addToEnd(e);
        list3.addToEnd('w');
        ...
        return 0;
     }
           

• The list class we have defined is an example of a container class.
  • A container class is a class used to implement a container.

  • A container is an object which holds other objects.

  • Examples of containers: array, stack, queue, list, set.

• We can also have class templates with more than one parameter.
  • Example: a look-up table, implemented as an array of key-value associations.

       template<class K, class V>
       class association {
          K key;
          V value;
       };
    
       association<int, person> mytable[100];
    	       

• We can also have concrete parameters.
  • Example:

       template<class K, class V, int size=100>
       class lookup {
          public:
    	 association<K, V> data[size];
       };
    
       lookup<int, person, 100> mytable;
    	       

Return to lecture notes index

Lectures