Lecture notes for CS 509, Advanced Programming II

Lecture Notes for CS 509, Advanced Programming II

1 April 2004, 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 EType>
struct stack {
  void push(const EType & e) {
    stk.push_back(e)
    }
  std::vector<EType> 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 EType>
struct stack {
  void push(const EType &)
  }

void stack::
push(const EType & e) { ... }

stack? What is stack? And what is EType?

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

Better, but what is EType?

template < typename EType >
void stack<EType>::
push(const EType & 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.
- Few compilers implement export.

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);
  }

Why I (heart) C++

A class's copy constructor and assignment operator are copying member functions.
- They copy one class instance to another instance of the same class.
- Remember the Rule of Three?
Template member functions never expand into copying member functions.
- Why? I don't know.

Consider the code

struct blob
  template < class T >
  blob(const T & t)
    cout << "blob::blob(const T &)"

  template < class T>
  blob & operator = (const T & t)
    cout << "blob::operator ="
    return *this;

Templates vs. Copying

Now consider the code

$ cat t.cc
int main() {
  blob b1;
  blob b2 = b1;
  b1 = b2;
  }

$ g++ -o t -ansi -pedantic -Wall t.cc

$ ./t

$

Nothing gets printed. Why?

blob has no explicit copy constructor and no assignment operator.
- The template member functions don't define them.
- The compiler supplies the default, bit-copying ones.
You can't use templates to define a copy constructor or assignment operator.

Instantiating Non-Copying Versions

Next up, consider the code

$ cat t.cc
struct frog { }

int main()
  frog f
  blob b1 = f
  b1 = f

$ g++ -o t -ansi -pedantic -Wall t.cc

$ ./t
blob::blob(const T &)
blob::operator =

$

A frog is not a blob, so no instance copying is done, and the template versions are instantiated.

Obey the Rule of Three

Always define explicit copy constructors and assignment operators if needed.

struct blob

  template < class T >
  blob(const T & t)
    cout << "blob::blob(const T &)"

  blob(const blob & t)
    cout << "blob::blob(blob)"

  template < class T >
  blob & operator = (const T & t)
    cout << "blob::operator == (T)"
    return *this

  blob & operator = (const blob & t) {
    cout << "blob::operator == (blob)"
    return *this

This looks ambiguous, but isn't.
- For the copying operators only.

Virtue Rewarded

The copy operations bind to the non-template definitions.

$ cat t.cc
int main()
  blob b1
  blob b2 = b1
  b1 = b2

$ g++ -o t -ansi -pedantic -Wall t.cc

$ ./t
blob::blob(const blob &)
blob::operator == (const blob &)

$

Vandevoorde and Josuttis apparently make this mistake on page 49 of C++ Templates, The Complete Guide.

template < typename T, class C = std::deque<T> >
class Stack
  template < typename T2, class C2>
  Stack<T, C> & operator = (const Stack<T2, C2> &);

template < typename T, class C>
  template < typename T2, class C2>
Stack<T, C> & Stack<T, C>::
operator = (const Stack<T2, C2> & rhs)
  if ((void *) this == (void *) &rhs) 
    // self assignment (not reached)

Value Template Parameters

A formal template parameter can represent an integral value.

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

The value template parameter is treated as a named constant.

Integral template value types include ints, pointers, and references.
- ints includes characters, enums, and booleans.
- A pointer to a class instance, function, or method only.
- A reference to a class instance or function only.
Use value template parameters whenever possible.
- Moves allocation from run-time to compile-time.
- Eliminates a source of run-time errors.

Default Template Parameter Values

Class template parameters can have default values.

template < typename EType, int size = 100 >
class stack { ... }

int main()
  stack<int, 200> istk
  stack<std::string> sstk

Each instance of a parameter value defines a different type.

$ cat t.cc
int main()
  stk<int, 10> s10
  stk<int, 20> s20
  s10 = s20

$ g++ -c -ansi -pedantic -Wall t.cc
t.cc: In function int main():
no match for stk<int,10>& = stk<int,20>&
candidates are: stk<int,10> & 
  stk<int,10>::operator=(const stk<int,10> &)

$

Do you see why template member functions might be useful?

Default Type Parameter Values

Template type parameters can have default types too.

template 
  < typename EType = int, int size = 100 >
class stack { ... }

int main()
  stack<blob, 200> bstk
  stack<std::string> sstk
  stack<> istk

Note that funky syntax.

Function template prameters cannot have default values.
- Neither value nor type.

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 your time when using separate definitions.
(Template, non-template) X (class, member function).
- The syntax gets horrendous.
Class template parameters can represent integral values.
- Integral values include ints, pointers, and references.
Class template parameters can have default values.
- Either type or value parameters can.
- But function template parameters can't.

This page last modified on 25 March 2004.