Templates

Example…

A useful routine to have is

void swap(int &a, int &b){

int tmp = a;

a = b;

b = tmp;

}

Example…

What happens if we want to swap a different type such as double and string?

For each one, we need different function, code duplication a known bug recipe!

void swap( double& a, double &b ) {double tmp = a; a = b; b = tmp;

}void swap( string& a, string &b ) {string tmp = a; a = b; b = tmp;

}

Generic Programming

All these versions of swap are “isomorphic”

// template code for swap for arbitrary type T

void Swap( T &a, T &b ) {

T tmp = a;

a = b;

b = tmp;

}

Can we somehow tell the compiler to use swap with any type T?

Templates

The template keyword defines “templates”Piece of code that will be regenerated with

different arguments each time.

template<class T> // T is a “type argument”void swap(T& a, T &b) {T tmp = a; a = b; b = tmp;

}

Template Instantiation

int main() {

int a = 2;

int b = 3;

swap(a, b);//requires swap(int&, int&)

}

• The compiler encounters swap(int&, int&)

• It instantiates the template swap with T = int

and compiles the code defined by it.• Same as: swap<int>(a,b);

Template Instantiation

• Different instantiations of a template can be generated by the same program.

• Swap example swap.cpp

Templates & Compilation

• A template is a declaration.• The compiler performs syntax checks only.• When a template is instantiated with specific

arguments, then the generated code is compiled

Implications:• Template code has to be visible by the code that

uses it (i.e., appear in .h file).• Compilation errors can occur only in a specific

instance (see swap.cpp).

Another Example…

// Inefficient generic sort…template< class T >void sort( T* begin, T* end ){ for( ; begin != end; begin++ ) for( T* q = begin+1; q != end; q++ ) if( *q < *begin ) swap( *q, *begin );

}

See [Sort.h, TestSort.cpp]

More Complex Case…

• Suppose we want to avoid writing operator != for new classes.

template <class T>

bool operator!= (T const& lhs, T const& rhs)

{

return !(lhs == rhs);

}

When is this template used?

More Complex Case…class MyClass {public:

…bool operator==(MyClass const & rhs) const;…

};…

int a, b;…if( a != b ) // uses built in operator!=(int,int) …MyClass x,y;if( x != y ) // uses template with T = MyClass …

When Templates are Used?Resolution

When the compiler encounters…f( a, b )…

• Search for a function f() with matching type signature.

• If not found, search for a template function that can be instantiated with matching types.

Generic Classes?

• Suppose we implement a class StrList that maintains a list of strings.– See StrList.h and StrList.cpp

• The actual code for maintaining the list has nothing to do with the particulars of the string type

• Can we have a generic implementation of lists?

Class Templates

template<class T>

class MyList {

…

};

…

MyList<int> intList; // T = int

MyList<string> stringList; // T = string

Class Templates

Code similar to usual code:

• Add template<…> statement before each top-level construct.

• Use template argument as type in class definition.

• Implementation of methods, somewhat more complex syntax. – See MyList.h TestMyList.h

Iterators

Constructing a List

• We want to initialize a list from an array.• We can write a method that receives a pointer to

the array, and a size argumentint array[] = { 1, 2, 3, 4, 5, 6 };

MyList<int> list;

list.copy( array, 6 );

• Alternative: use a pointer to initial position and one to the position after the lastlist.copy( array, array+6 );

• This form is more flexible (as we shall see)

Constructing a List

// Fancy copy from array

template< class T >

MyList<T>::copy( T const* begin,

T const* end )

{

T const* p;

for( p = begin; p != end; p++ )

pushBack(*p);

}

Pointer Paradigm

C/C++ idiom :T * p;

for( p = begin; p != end; p++ )

{

// Do something with *p

}

• Applies to all elements in [begin,end-1]

• Common in C/C++ programs

• Can we extend it to other containers?

Iterator

• Object that behaves just like a pointer.

• Allows to iterate over elements of a container.

Example:MyList<int> L;

…

MyList<int>::iterator i;

for( i = L.begin(); i != L.end(); i++ )

cout << " " << *i << "\n";

Iterators

To emulate pointers, we need:

• copy constructor for function call.

• operator = for assignments.

• operator == comparing two pointers.

• operator * for accessing a value

• operator++ for pointer arithmetic.

MyList<T> iterator

• Keep a pointer to a nodeclass iterator {

…

private:

Node m_pointer;

};

• Provide encapsulation, since through such an iterator we cannot change the structure of the list

See MyListWithIterators.h

Side Note operator++

In C we can use ++ in two forms:• prefix notation ++x

– increment x– fetch x’s value

• postfix notation x++– fetch x’s value– increment x

How can we implement both variants?

Operator++

• Prefix form:T& T::operator++();

• Postfix formT T::operator++(int); // dummy argument!

• Note different return types

See MyListWithIterators.h

Initializing a List

• We now want to initialize a list from using parts of another list

• Something liketemplate< class T >MyList<T>::copy( iterator begin, iterator end ){ iterator p; for( p = begin; p != end; p++ ) pushBack(*p);}

Generic Constructor

• The code for copying using – T* – MyList<T>::iterator

are essentially identical– on purpose --- iterators mimic pointers

Can we write the code once?

Template within a templatetemplate < class T > class MyList {

…

template< class Iterator >

copy( Iterator begin, Iterator end )

{

for( Iterator p = begin; p != end; p++ )

pushBack(*p);

}

…

};

Copy Method

• MyList<T>::copy() can be instantiated with different types– pointer to T– MyList<T>::iterator– Iterators of other data structures that contain

objects of type T

Template Variations

• Can receive constant argumentstemplate< class T, int Size = 1024>

class Buffer {

…

private:

T m_values[Size];

};

…

Buffer<char> Buff1;

Buffer<char,1024> Buff2; // same as Buff1

Buffer<int, 256> Buff3;

Template and Types

• Buffer is not a type • Buffer<char,1024> is a type• Buffer<char>, buffer<char,1024> are

two names for the same type• Buffer<char,256> is a different type

Class Templates - Recap

• Provides support for generic programming• Parameters are either types or constants.

Default values can be specified.• Depends only on the properties it uses

from its parameter types.• Resulting classes may be very efficient,

but code size may be larger.• Difficult to write, maintain and debug.• Class template overloading is impossible.

Summary

• Use templates to express algorithms that apply to many argument types.

• Use template to express containers.• Alternative mechanism to polymorphism.• Write & Debug concrete example before

generalizing to a template• Understand iterators and other “helper”

classes• Foundation for C++ standard library (STL)

Things to read about

Standard Library

• <string> – implementation of string

• <algorithm> - algorithms (sort, swap, etc.)

• <utility> - relational operators