2003 Prentice Hall, Inc. All rights reserved.

1
Chapter 11 - Templates
Outline
11.1 Introduction
11.2 Function Templates
11.3 Overloading Function Templates
11.4 Class Templates
11.5 Class Templates and Nontype Parameters
11.6 Templates and Inheritance
11.7 Templates and Friends
11.8 Templates and static Members
2003 Prentice Hall, Inc. All rights reserved.
2
11.1 Introduction
Templates
Function templates
Specify entire range of related (overloaded) functions
Function-template specializations
Class templates
Specify entire range of related classes
Class-template specializations

2003 Prentice Hall, Inc. All rights reserved.
3
11.2 Function Templates
Overloaded functions
Similar operations
Different types of data
Function templates
Identical operations
Different types of data
Single function template
Compiler generates separate object-code functions
Type checking
2003 Prentice Hall, Inc. All rights reserved.
4
11.2 Function Templates
Function-template definitions
Keyword template
List formal type parameters in angle brackets (< and >)
Each parameter preceded by keyword class or typename
class and typename interchangeable
template< class T >
template< typename ElementType >
template< class BorderType, class FillType >
Specify types of
Arguments to function
Return type of function
Variables within function
2003 Prentice Hall, Inc.
All rights reserved.
Outline
5
fig11_01.cpp
(1 of 2)


1 // Fig. 11.1: fig11_01.cpp
2 // Using template functions.
3 #include <iostream>
4
5 using std::cout;
6 using std::endl;
7
8 // function template printArray definition
9 template< class T >
10 void printArray( const T *array, const int count )
11 {
12 for ( int i = 0; i < count; i++ )
13 cout << array[ i ] << " ";
14
15 cout << endl;
16
17 } // end function printArray
18
19 int main()
20 {
21 const int aCount = 5;
22 const int bCount = 7;
23 const int cCount = 6;
24
Function template definition;
declare single formal type
parameter T.
T is type parameter; use any
valid identifier.
If T is user-defined type,
stream-insertion operator
must be overloaded for class
T.
2003 Prentice Hall, Inc.
All rights reserved.
Outline
6
fig11_01.cpp
(2 of 2)


25 int a[ aCount ] = { 1, 2, 3, 4, 5 };
26 double b[ bCount ] = { 1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7 };
27 char c[ cCount ] = "HELLO"; // 6th position for null
28
29 cout << "Array a contains:" << endl;
30
31 // call integer function-template specialization
32 printArray( a, aCount );
33
34 cout << "Array b contains:" << endl;
35
36 // call double function-template specialization
37 printArray( b, bCount );
38
39 cout << "Array c contains:" << endl;
40
41 // call character function-template specialization
42 printArray( c, cCount );
43
44 return 0;
45
46 } // end main

Creates complete function-template specialization for printing
array of ints:

void printArray( const int *array, const int count )
{
for ( int i = 0; i < count; i++ )
cout << array[ i ] << " "
cout << endl;
} // end function printArray

Compiler infers T is
double; instantiates
function-template
specialization where T is
double.
Compiler infers T is char;
instantiates function-template
specialization where T is
char.
2003 Prentice Hall, Inc.
All rights reserved.
Outline
7
fig11_01.cpp
output (1 of 1)


Array a contains:
1 2 3 4 5
Array b contains:
1.1 2.2 3.3 4.4 5.5 6.6 7.7
Array c contains:
H E L L O
2003 Prentice Hall, Inc. All rights reserved.
8
11.3 Overloading Function Templates
Related function-template specializations
Same name
Compiler uses overloading resolution
Function template overloading
Other function templates with same name
Different parameters
Non-template functions with same name
Different function arguments
Compiler performs matching process
Tries to find precise match of function name and argument
types
If fails, function template
Generate function-template specialization with precise
match
2003 Prentice Hall, Inc. All rights reserved.
9
11.4 Class Templates
Stack
LIFO (last-in-first-out) structure
Class templates
Generic programming
Describe notion of stack generically
Instantiate type-specific version
Parameterized types
Require one or more type parameters
Customize generic class template to form class-template
specialization
2003 Prentice Hall, Inc.
All rights reserved.
Outline
10
tstack1.h (1 of 4)


1 // Fig. 11.2: tstack1.h
2 // Stack class template.
3 #ifndef TSTACK1_H
4 #define TSTACK1_H
5
6 template< class T >
7 class Stack {
8
9 public:
10 Stack( int = 10 ); // default constructor (stack size 10)
11
12 // destructor
13 ~Stack()
14 {
15 delete [] stackPtr;
16
17 } // end ~Stack destructor
18
19 bool push( const T& ); // push an element onto the stack
20 bool pop( T& ); // pop an element off the stack
21

Specify class-template
definition; type parameter T
indicates type of Stack class
to be created.
Function parameters of type
T.
2003 Prentice Hall, Inc.
All rights reserved.
Outline
11
tstack1.h (2 of 4)


22 // determine whether Stack is empty
23 bool isEmpty() const
24 {
25 return top == -1;
26
27 } // end function isEmpty
28
29 // determine whether Stack is full
30 bool isFull() const
31 {
32 return top == size - 1;
33
34 } // end function isFull
35
36 private:
37 int size; // # of elements in the stack
38 int top; // location of the top element
39 T *stackPtr; // pointer to the stack
40
41 }; // end class Stack
42

Array of elements of type T.
2003 Prentice Hall, Inc.
All rights reserved.
Outline
12
tstack1.h (3 of 4)


43 // constructor
44 template< class T >
45 Stack< T >::Stack( int s )
46 {
47 size = s > 0 ? s : 10;
48 top = -1; // Stack initially empty
49 stackPtr = new T[ size ]; // allocate memory for elements
50
51 } // end Stack constructor
52
53 // push element onto stack;
54 // if successful, return true; otherwise, return false
55 template< class T >
56 bool Stack< T >::push( const T &pushValue )
57 {
58 if ( !isFull() ) {
59 stackPtr[ ++top ] = pushValue; // place item on Stack
60 return true; // push successful
61
62 } // end if
63
64 return false; // push unsuccessful
65
66 } // end function push
67
Member functions preceded
with header

template< class T >
Use binary scope resolution
operator (::) with class-
template name (Stack< T >)
to tie definition to class
templates scope.
Constructor creates array of type T.
For example, compiler generates

stackPtr = new T[ size ];

for class-template specialization
Stack< double >.
2003 Prentice Hall, Inc.
All rights reserved.
Outline
13
tstack1.h (4 of 4)


68 // pop element off stack;
69 // if successful, return true; otherwise, return false
70 template< class T >
71 bool Stack< T >::pop( T &popValue )
72 {
73 if ( !isEmpty() ) {
74 popValue = stackPtr[ top-- ]; // remove item from Stack
75 return true; // pop successful
76
77 } // end if
78
79 return false; // pop unsuccessful
80
81 } // end function pop
82
83 #endif

Member function preceded
with header

template< class T >
Use binary scope resolution
operator (::) with class-
template name (Stack< T >)
to tie definition to class
templates scope.
2003 Prentice Hall, Inc.
All rights reserved.
Outline
14
fig11_03.cpp
(1 of 3)


1 // Fig. 11.3: fig11_03.cpp
2 // Stack-class-template test program.
3 #include <iostream>
4
5 using std::cout;
6 using std::cin;
7 using std::endl;
8
9 #include "tstack1.h" // Stack class template definition
10
11 int main()
12 {
13 Stack< double > doubleStack( 5 );
14 double doubleValue = 1.1;
15
16 cout << "Pushing elements onto doubleStack\n";
17
18 while ( doubleStack.push( doubleValue ) ) {
19 cout << doubleValue << ' ';
20 doubleValue += 1.1;
21
22 } // end while
23
24 cout << "\nStack is full. Cannot push " << doubleValue
25 << "\n\nPopping elements from doubleStack\n";

Link to class template
definition.
Instantiate object of class
Stack< double >.
Invoke function push of
class-template specialization
Stack< double >.
2003 Prentice Hall, Inc.
All rights reserved.
Outline
15
fig11_03.cpp
(2 of 3)


26
27 while ( doubleStack.pop( doubleValue ) )
28 cout << doubleValue << ' ';
29
30 cout << "\nStack is empty. Cannot pop\n";
31
32 Stack< int > intStack;
33 int intValue = 1;
34 cout << "\nPushing elements onto intStack\n";
35
36 while ( intStack.push( intValue ) ) {
37 cout << intValue << ' ';
38 ++intValue;
39
40 } // end while
41
42 cout << "\nStack is full. Cannot push " << intValue
43 << "\n\nPopping elements from intStack\n";
44
45 while ( intStack.pop( intValue ) )
46 cout << intValue << ' ';
47
48 cout << "\nStack is empty. Cannot pop\n";
49
50 return 0;

Invoke function pop of class-
template specialization
Stack< double >.
Note similarity of code for
Stack< int > to code for
Stack< double >.
2003 Prentice Hall, Inc.
All rights reserved.
Outline
16
fig11_03.cpp
(3 of 3)

fig11_03.cpp
output (1 of 1)


51
52 } // end main

Pushing elements onto doubleStack
1.1 2.2 3.3 4.4 5.5
Stack is full. Cannot push 6.6

Popping elements from doubleStack
5.5 4.4 3.3 2.2 1.1
Stack is empty. Cannot pop

Pushing elements onto intStack
1 2 3 4 5 6 7 8 9 10
Stack is full. Cannot push 11

Popping elements from intStack
10 9 8 7 6 5 4 3 2 1
Stack is empty. Cannot pop
2003 Prentice Hall, Inc.
All rights reserved.
Outline
17
fig11_04.cpp
(1 of 2)


1 // Fig. 11.4: fig11_04.cpp
2 // Stack class template test program. Function main uses a
3 // function template to manipulate objects of type Stack< T >.
4 #include <iostream>
5
6 using std::cout;
7 using std::cin;
8 using std::endl;
9
10 #include "tstack1.h" // Stack class template definition
11
12 // function template to manipulate Stack< T >
13 template< class T >
14 void testStack(
15 Stack< T > &theStack, // reference to Stack< T >
16 T value, // initial value to push
17 T increment, // increment for subsequent values
18 const char *stackName ) // name of the Stack < T > object
19 {
20 cout << "\nPushing elements onto " << stackName << '\n';
21
22 while ( theStack.push( value ) ) {
23 cout << value << ' ';
24 value += increment;
25
26 } // end while
Function template to manipulate
Stack< T > eliminates similar
code from previous file for
Stack< double > and
Stack< int >.
2003 Prentice Hall, Inc.
All rights reserved.
Outline
18
fig11_04.cpp
(2 of 2)


27
28 cout << "\nStack is full. Cannot push " << value
29 << "\n\nPopping elements from " << stackName << '\n';
30
31 while ( theStack.pop( value ) )
32 cout << value << ' ';
33
34 cout << "\nStack is empty. Cannot pop\n";
35
36 } // end function testStack
37
38 int main()
39 {
40 Stack< double > doubleStack( 5 );
41 Stack< int > intStack;
42
43 testStack( doubleStack, 1.1, 1.1, "doubleStack" );
44 testStack( intStack, 1, 1, "intStack" );
45
46 return 0;
47
48 } // end main

2003 Prentice Hall, Inc.
All rights reserved.
Outline
19
fig11_04.cpp
output (1 of 1)


Pushing elements onto doubleStack
1.1 2.2 3.3 4.4 5.5
Stack is full. Cannot push 6.6

Popping elements from doubleStack
5.5 4.4 3.3 2.2 1.1
Stack is empty. Cannot pop

Pushing elements onto intStack
1 2 3 4 5 6 7 8 9 10
Stack is full. Cannot push 11

Popping elements from intStack
10 9 8 7 6 5 4 3 2 1
Stack is empty. Cannot pop


Note output identical to that
of fig11_03.cpp.
2003 Prentice Hall, Inc. All rights reserved.
20
11.5 Class Templates and Nontype
Parameters
Class templates
Nontype parameters
Default arguments
Treated as consts
Example:
template< class T, int elements >
Stack< double, 100 > mostRecentSalesFigures;
Declares object of type Stack< double, 100>
Type parameter
Default type
Example:
template< class T = string >

2003 Prentice Hall, Inc. All rights reserved.
21
11.5 Class Templates and Nontype
Parameters
Overriding class templates
Class for specific type
Does not match common class template
Example:
template<>
Class Array< Martian > {
// body of class definition
};


2003 Prentice Hall, Inc. All rights reserved.
22
11.6 Templates and Inheritance
Several ways of relating templates and inheritance
Class template derived from class-template specialization
Class template derived from non-template class
Class-template specialization derived from class-template
specialization
Non-template class derived from class-template
specialization
2003 Prentice Hall, Inc. All rights reserved.
23
11.7 Templates and Friends
Friendships between class template and
Global function
Member function of another class
Entire class
2003 Prentice Hall, Inc. All rights reserved.
24
11.7 Templates and Friends
friend functions
Inside definition of template< class T > class X
friend void f1();
f1() friend of all class-template specializations
friend void f2( X< T > & );
f2( X< float > & ) friend of X< float > only,
f2( X< double > & ) friend of X< double > only,
f2( X< int > & ) friend of X< int > only,

friend void A::f4();
Member function f4 of class A friend of all class-template
specializations
2003 Prentice Hall, Inc. All rights reserved.
25
11.7 Templates and Friends
friend functions
Inside definition of template< class T > class X
friend void C< T >::f5( X< T > & );
Member function C<float>::f5( X< float> & )
friend of class X<float> only
friend classes
Inside definition of template< class T > class X
friend class Y;
Every member function of Y friend of every class-template
specialization
friend class Z<T>;
class Z<float> friend of class-template
specialization X<float>, etc.

2003 Prentice Hall, Inc. All rights reserved.
26
11.8 Templates and static Members
Non-template class
static data members shared between all objects
Class-template specialization
Each has own copy of static data members
static variables initialized at file scope
Each has own copy of static member functions