5/14/2014

Lecture 7 Templates
(C++)
CS162 Object Oriented Programming
Lecture adapted from Imran Ihsan
C++ How to Program (9th Edition) [Link]
By Paul Deitel and Harvey Deitel
Prentice Hall, Inc. All rights reserved. OOP 07 - Templates [Link]

+ 7.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

[Link] OOP 07 - Templates

1
 5/14/2014

+ 7.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

[Link] OOP 07 - Templates

+ 7.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

[Link] OOP 07 - Templates

2
 5/14/2014

+ 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

[Link] OOP 07 - Templates

+ 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

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

[Link] OOP 07 - Templates

3
 5/14/2014

+ 7.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

[Link] OOP 07 - Templates

+ 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

[Link] OOP 07 - Templates

4
 5/14/2014

+ 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

[Link] OOP 07 - Templates

+ 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

[Link] OOP 07 - Templates

5
 5/14/2014

+ 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

[Link] OOP 07 - Templates

+ 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

[Link] OOP 07 - Templates

6
 5/14/2014

+ 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 ( [Link]( 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] OOP 07 - Templates

+ 26
27 while ( [Link]( 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 ( [Link]( 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 ( [Link]( intValue ) )
46 cout << intValue << ' ';
47
48 cout << "\nStack is empty. Cannot pop\n";
49
50 return 0;

[Link] OOP 07 - Templates

7
 5/14/2014

+ 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

[Link] OOP 07 - Templates

+ 7.5 Class Templates & 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 >

[Link] OOP 07 - Templates

8
 5/14/2014

+ 7.5 Class Templates & Nontype Parameters

Overriding class templates

Class for specific type
Does not match common class template

Example:
template<>
Class Array< Martian > {
// body of class definition
};

[Link] OOP 07 - Templates

+ 7.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

[Link] OOP 07 - Templates

9
 5/14/2014

+ 7.7 Templates and Friends

Friendships between class template and

Global function
Member function of another class
Entire class

[Link] OOP 07 - Templates

10