Templates

    Reading: Dietel sections 12.1-12.5

Polymorphism

• Ability of a variable to take on more than one form
• Virtual functions, dynamic binding
• We want to parameterize:
      Let a class take on more than one form
      Let a function take on more than one form
• Function and class templates can accomplish this

Motivation

• Often want to accomplish similar taks for different types
• Could overload functions for each data type
      float max ( const float a, const float b );
      int max ( const int a, const int b );
      Rational max ( const Rational& a, const Rational& b);
      myType max ( const myType& a, const myType& b); // avoid copy overhead
• Code for each looks the same
      return ( a < b )? b : a ;
• Algorithm itself is independent of data type
• We must assume that any type implements "<"

Template Functions

• We can write a single function to handle all of the above:
  
  
  template <class T>

  T max ( const T& a, const T& b )

  {  return ( a < b ) ? b : a; }
• T is the "template parameter"; can have any name
• Compiler creates different versions of the function as they are called:
  
      int a, b, c;
      c = max ( a, b );
  
              will create
  
      int max ( const int& a, const int& b)
      {  return ( a < b ) ? b : a ;  }
  
•     Rational a, b, c;
      c = max ( a, b );
  
              will create
  
      Rational max ( const Rational& a, const Rational& b)
      {  return ( a < b ) ? b : a ;  }
  
•     SomeType a, b, c;
      c = max ( a, b );
  
              will create
  
      SomeType max ( const SomeType& a, const SomeType& b)
      {  return ( a < b ) ? b : a ;  }
  
• Callers of function don't need to know it's a template function; calls don't need to change.
  

Caution

• Watch out for atypical cases:
  
      char* a, b, c;
      c = max ( a, b );
  
              will create
  
      char* max ( const char* & a, const char* & b)
      {  return ( a < b ) ? b : a ;  }
• This compares addresses, not lexicographic ordering
• Can provide an explicit max for char*'s:
  
  char* max(char *a, char *b)

  {

  if ( strcmp ( a, b ) < 0 )

      return b;

  return a;

  }

 

• Compiler will look for an exact function signature match before resorting to templates

 

Template Classes

• We can parameterize classes in this way also
• Generate generic classes to work with any type of data
• Generate "container" classes ( list, stack, queue, etc. ) which are independent of underlying data type

Revisiting the SmartArray Class

• Remember the class:
  
  class SmartArray {
  public:
      smartArray ( int size = 100 );
      // other member functions
  private:
      int _size;
      int *_theData; // this is what makes it a SmartArray of ints

  };
  
• Nothing in our code requires the array elements to be ints
• We only need to be able to insert, remove, and access individual elements
• So we could make a SmartArray of any element type without much recoding of SmartArray's methods:
  
  template <class T>

  class SmartArray {
  public:
      SmartArray ( int size = 100 );
      SmartArray ( const SmartArray& );
      T& operator [ ] ( int );
  
  private:
      int  size; // this really is an int
      T* data; // the array of any type

  };
• Now the member functions become template functions:
  
  
  template <class T>        // constructor

  SmartArray <T> :: SmartArray ( int newsize )

  {
    size = new size;
    data = new T [ size ]; // an array of Ts
  

  }