1 / 32

Templates - PowerPoint PPT Presentation

  • Updated 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

PowerPoint Slideshow about ' Templates' - albert

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

Example l.jpg

A useful routine to have is

void Swap( int& a, int &b )


int tmp = a;

a = b;

b = tmp;


Example3 l.jpg

  • 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 l.jpg
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?

Templates5 l.jpg

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 l.jpg
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 l.jpg
Template Instantiation

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

  • See Swap.cpp

Templates compilation l.jpg
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 l.jpg
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 l.jpg
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 l.jpg
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 l.jpg
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 l.jpg
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 l.jpg
Class Templates

template<class T>

class MyList {


MyList<int> intList; // T = int

MyList<string> stringList; // T = string

Class templates15 l.jpg
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 l.jpg
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 l.jpg
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 l.jpg
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?

Iterator l.jpg

  • 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";

Iterators l.jpg

To emulate pointers, we need:

  • copy constructor

  • operator = (copy)

  • operator == (compare)

  • operator * (access value)

  • operator++ (increment)

Mylist t iterator l.jpg
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 l.jpg
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 l.jpg

  • Prefix form:

    T& T::operator++();

  • Postfix form

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

  • Note different return types

    See MyListWithIterators.h

Initializing a list l.jpg
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 l.jpg
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 l.jpg
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 l.jpg
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 l.jpg
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 l.jpg
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 l.jpg
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 l.jpg

  • 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 l.jpg
Things to read about

Standard Library

  • <string> – implementation of string

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

  • <utility> - relational operators