Lecture Notes for CS 509, Advanced Programming II

18 April 2002, Template Classes

Outline

• Template classes

  • Syntax

  • Declarations

  • Declarations and definitions

  • Declarations, definitions, and .h

• Template classes and functions

  • Class and member templates

• Integral template parameters

Template Classes

• Sometimes, types don't matter for classes.

  • Stacks of things, queues of things.

  • Although usually, types do matter.

    • Operations (including create, copy, and destroy) on type values.

• As with functions, classes can represent types with template parameters.

• The STL should have prepped you for this by now.

Template Class Syntax

• The class template header is the same as the function template header.

  template < class type-param [ , class type-param ]... >
  class class-name { ... }
  

  typename works for class too.

• Within the class, template parameters can be used as type specs.

  template <typename ElementType>
  struct stack {
    void push(const ElementType & e) {
      stk.push_back(e)
      }
    std::vector<ElementType> stk
    };
  

• As with functions, the typename keyword may be necessary to indicate type specs.

  template <class ContainerType>
  struct C {
    typename ContainerType::value_type front()  { 
      return c.front()
      }
    ContainerType c
    }
  

Template-Class Declarations

• Unlike functions, there are no actual parameters.

  • The compiler can't discover the template parameter types.

• The parameter types are part of the template-class name.

  stack<int> istk
  
  std::map<std::string, int> dictionary
  

• As for functions, template type matching is exact.

  • The problem is usually operations on template-type values.

• Don't forget the >> problem.

Declarations and Definitions

• Remember: the parameter types are part of the class name.

• This is important when declaration and definition are separate.

  template <typename ElementType>
  struct stack {
    void push(const ElementType &)
    }
  
  void stack::
  push(const ElementType & e) { ... }
  

• stack? What is stack? And what is ElementType?

  void stack<ElementType>::
  push(const ElementType & e) { ... }
  

• Better, but what is ElementType?

  template < typename ElementType >
  void stack<ElementType>::
  push(const ElementType & e) { ... }
  

• Ta da.

Declarations, Definitions, and .h

• Templates must be defined in the same file they're used.

  • The compiler doesn't know about them otherwise.

• This leads to putting definitions in .h files.

  • Usually, definitions in .h files is frowned upon.

  • Template definitions must be in .h files.

• A classic newbie error:

  • Template declarations in a .h file.

  • Template definitions in a .cc file.

  • No compilations at all.

• Separate declarations and definitions are allowed.

  • Some compilers used to provide separate definitions.

  • Some still do, via pragmas.

  • The standard allows separated definitions via the export keyword.

  • No compilers implement export yet.

Template Classes and Functions

• Member functions are functions and can have templates too.

  • This is separate from what the class does.

• There are four combinations:

  1. Non-template members of non-template classes.

  2. Non-template members of template classes.

  3. Template members of non-template classes.

  4. Template members of template classes.

• Each template member function defines a new function, not a new class.

Class and Member Templates

• Class and member-function template parameters can be mixed, carefully.

  template < class A, class B >
  struct C1 {
    template < typename X, typename Y >
    A f(X x, Y y) { 
      B b;
      }
    };
  
  int main() {
    C1<int, std::string> c;
    int i = c.f(1, 'a');
    int j = c.f("hello", 1.0);
    }
  

Integral Template Parameters

• A formal template parameter can have integral type.

  template < typename ElementType, int size >
  class stack {
    void push(const ElementType & e) {
      if (top >= size) { ... }
      }
    private:
      ElementType arr[size]
    }
  

  The integral template parameter is treated as a const.

• Integral template parameters can have default values.

  template < typename ElementType, int size = 100 >
  class stack { ... }
  
  int main() {
    stack<int, 200> istk
    stack<std::string> sstk
    }
  

• Use integral template parameters whenever possible.

  • Moves allocation from run-time to compile-time.

  • Eliminates a source of run-time errors.

Points to Remember

• Templates generalize classes by types.

  • Even more polymorphism.

• Template class syntax is similar to template function syntax.

  • Functions without parameters, that is.

• The template parameters are part of the class name.

  • Take you time when using separate definitions.

• (Template, non-template) X (class, member function).

  • The syntax gets horrendous.

This page last modified on 22 November 2002.