templates l.
Skip this Video
Loading SlideShow in 5 Seconds..
Templates PowerPoint Presentation
Download Presentation

Loading in 2 Seconds...

play fullscreen
1 / 32

Templates - PowerPoint PPT Presentation

  • Uploaded on

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 double ? or a string ? For each one, we need different function: void Swap( double& a, double &b ) {

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.
Download Presentation


An Image/Link below is provided (as is) to download presentation

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

A useful routine to have is

void Swap( int& a, int &b )


int tmp = a;

a = b;

b = tmp;


  • What happens if we want to swap a double ? or a string?

For each one, we need different function:

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
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?

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
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 = intand compiles the code defined by it
template instantiation7
Template Instantiation
  • Different instantiations of a template can be generated by the same program
  • See Swap.cpp
templates compilation
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


  • 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
Another Example…

// Inefficient generic sort…

template< class T >


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
More Complex Case…
  • Suppose we want to avoid writing operator != for new classes

template <class T>


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


return !(lhs == rhs);


When is this template used?

more complex case11
More Complex Case…

class MyClass {


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
When Templates are Used?

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
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
Class Templates

template<class T>

class MyList {


MyList<int> intList; // T = int

MyList<string> stringList; // T = string

class templates15
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
constructing a list
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 argument

int 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 last

list.copy( array, array+6 );

  • This form is more flexible (as we shall see)
constructing a list17
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++ )



pointer paradigm
Pointer Paradigm

Code like:

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?
  • Object that behaves just like a pointer
  • Allows to iterate over elements of a container


MyList<int> L;

MyList<int>::iterator i;

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

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


To emulate pointers, we need:

  • copy constructor
  • operator = (copy)
  • operator == (compare)
  • operator * (access value)
  • operator++ (increment)
mylist t iterator
MyList<T> iterator
  • Keep a pointer to a node

class iterator {


Node m_pointer;


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

See MyListWithIterators.h

side note operator
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?

  • Prefix form:

T& T::operator++();

  • Postfix form

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

  • Note different return types

See MyListWithIterators.h

initializing a list
Initializing a List
  • We now want to initialize a list from using parts of another list
  • Something like

template< class T >

MyList<T>::copy( iterator begin,

iterator end )


iterator p;

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



generic constructor
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 template
Template within a template

template < class T > class MyList {

template< class Iterator >

copy( Iterator begin, Iterator end )


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




copy method
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
Template Variations
  • Can receive constant arguments

template< class T, int Size = 1024>

class Buffer {


T m_values[Size];


Buffer<char> Buff1;

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

Buffer<int, 256> Buff3;

template and types
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
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
  • Alternative mechanism to polymorphism
  • Write & Debug concrete example (e.g., StringList) before generalizing to a template
  • Understand iterators and other “helper” classes
  • Foundation for C++ standard library (STL)
things to read about
Things to read about

Standard Library

  • <string> – implementation of string
  • <algorithm> - algorithms (sort, swap, etc.)
  • <utility> - relational operators