CSC 213 Chapter 12, Fall 2007
Notre Dame University–Louaize · Program Design and Data Abstraction II · 20 pages
Showing the first 10 of 20 pages. Download the PDF to see all of it.
More CSC 213 files
Show the text of this chapter
2000 Deitel & Associates, Inc. All rights reserved.
2000 Deitel & Associates, Inc. All rights reserved.
Chapter 12 - Templates
Outline
12.1
Introduction
12.2
Function Templates
12.3
Overloading Template Functions
12.4
Class Templates
12.5
Class Templates and Non-type Parameters
12.6
Templates and Inheritance
12.7
Templates and friends
12.8
Templates and static Members
2000 Deitel & Associates, Inc. All rights reserved.
2000 Deitel & Associates, Inc. All rights reserved.
12.1 Introduction
• Templates - easily create a large range of related
functions or classes
– function template - the blueprint of the related functions
– template function - a specific function made from a function
template
2000 Deitel & Associates, Inc. All rights reserved.
2000 Deitel & Associates, Inc. All rights reserved.
12.2 Function Templates
• overloaded functions
– perform similar operations on different data types
• function templates
– perform identical operations on different data types
– provide type checking
• Format:
template<class type, class type...>
– can use class or typename - specifies type parameters
template< class T >
template< typename ElementType >
template< class BorderType, class FillType >
– Function definition follows template statement
2000 Deitel & Associates, Inc. All rights reserved.
2000 Deitel & Associates, Inc. All rights reserved.
12.2 Function Templates (II)
1
template< class T >
2
void printArray( const T *array, const int count
)
3
{
4
for ( int i = 0; i < count; i++ )
5
cout << array[ i ] << " ";
6
7
cout << endl;
8
}
The int version of printArray is
void printArray( const int *array, const int count )
{
for ( int i = 0; i < count; i++ )
cout << array[ i ] << " ";
cout << endl;
}
T is the type parameter. T's type
is detected and substituted inside
the function.
The newly created function is
compiled.
2000 Deitel & Associates, Inc. All rights reserved.
2000 Deitel & Associates, Inc. All rights reserved.
Outline
1. Function template
definition
1.1 Initialize variables
2. Call template
functions
3. Output
1
// Fig 12.2: fig12_02.cpp
2
// Using template functions
3
#include <iostream>
4
5
using std::cout;
6
using std::endl;
7
8
template< class T >
9
void printArray( const T *array, const int count )
10 {
11 for ( int i = 0; i < count; i++ )
12 cout << array[ i ] << " ";
13
14 cout << endl;
15 }
16
17 int main()
18 {
19 const int aCount = 5, bCount = 7, cCount = 6;
20 int a[ aCount ] = { 1, 2, 3, 4, 5 };
21 double b[ bCount ] = { 1.1, 2.2, 3.3, 4.4, 5.5, 6.6, 7.7 };
22 char c[ cCount ] = "HELLO"; // 6th position for null
23
24 cout << "Array a contains:" << endl;
25 printArray( a, aCount ); // integer template function
26
27 cout << "Array b contains:" << endl;
28 printArray( b, bCount ); // double template function
29
30 cout << "Array c contains:" << endl;
31 printArray( c, cCount ); // character template function
32
33 return 0;
34 }
Notice how type parameter T is
used in place of int, float, etc.
.
Each type array gets operated on by
a different template function.
2000 Deitel & Associates, Inc. All rights reserved.
2000 Deitel & Associates, Inc. All rights reserved.
Outline
Program Output
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
2000 Deitel & Associates, Inc. All rights reserved.
2000 Deitel & Associates, Inc. All rights reserved.
12.3 Overloading Template Functions
• related template functions have same name
– compiler uses overloading resolution to call the right one
• function template can be overloaded
– other function templates can have same name but different number
of parameters
– non-template function can have same name but different
arguments
• compiler tries to match function call with function
name and arguments
– if no precise match, looks for function templates
• if found, compiler generates and uses template function
– if no matches or multiple matches are found, compiler gives error
2000 Deitel & Associates, Inc. All rights reserved.
2000 Deitel & Associates, Inc. All rights reserved.
12.4 Class Templates
• class templates
– allow type-specific versions of generic classes
• Format:
template <class T>
class ClassName{
definition
}
– Need not use "T", any identifier will work
– To create an object of the class, type
ClassName< type > myObject;
Example: Stack< double > doubleStack;
2000 Deitel & Associates, Inc. All rights reserved.
2000 Deitel & Associates, Inc. All rights reserved.
12.4 Class Templates (II)
• Template class functions
– declared normally, but preceded by template<class T>
• generic data in class listed as type T
– binary scope resolution operator used
– Template class function definition:
template<class T>
MyClass< T >::MyClass(int size)
{
myArray = new T[size];
}
• constructor definition - creates an array of type T
2000 Deitel & Associates, Inc. All rights reserved.
2000 Deitel & Associates, Inc. All rights reserved.
Outline
1. Class template
definition
1.1 Function definitions
1.2 Stack constructor
1
// Fig. 12.3: tstack1.h
2
// Class template Stack
3
#ifndef TSTACK1_H
4
#define TSTACK1_H
5
6
template< class T >
7
class Stack {
8
public:
9
Stack( int = 10 ); // default constructor (stack size 10)
10 ~Stack() { delete [] stackPtr; } // destructor
11 bool push( const T& ); // push an element onto the stack
12 bool pop( T& ); // pop an element off the stack
13 private:
14 int size; // # of elements in the stack
15 int top; // location of the top element
16 T *stackPtr; // pointer to the stack
17
18 bool isEmpty() const { return top == -1; } // utility
19 bool isFull() const { return top == size - 1; } // functions
20 };
21
22 // Constructor with default size 10
23 template< class T >
24 Stack< T >::Stack( int s )
25 {
26 size = s > 0 ? s : 10;
27 top = -1; // Stack is initially empty
28 stackPtr = new T[ size ]; // allocate space for elements
29 }
Notice how a member function of the class
template is defined
2000 Deitel & Associates, Inc. All rights reserved.
2000 Deitel & Associates, Inc. All rights reserved.
Outline
1.3 push
1.4 pop
30
31 // Push an element onto the stack
32 // return 1 if successful, 0 otherwise
33 template< class T >
34 bool Stack< T >::push( const T &pushValue )
35 {
36 if ( !isFull() ) {
37 stackPtr[ ++top ] = pushValue; // place item in Stack
38 return true; // push successful
39 }
40 return false; // push unsuccessful
41 }
42
43 // Pop an element off the stack
44 template< class T >
45 bool Stack< T >::pop( T &popValue )
46 {
47 if ( !isEmpty() ) {
48 popValue = stackPtr[ top-- ]; // remove item from Stack
49 return true; // pop successful
50 }
51 return false; // pop unsuccessful
52 }
53
54 #endif
Test if the stack is full. If not,
push element.
Test if the stack is empty. If
not, pop an element.
2000 Deitel & Associates, Inc. All rights reserved.
2000 Deitel & Associates, Inc. All rights reserved.
Outline
1. Load header
1.1 Initialize
doubleStack
1.2 Initialize variables
2. Function calls
55 // Fig. 12.3: fig12_03.cpp
56 // Test driver for Stack template
57 #include <iostream>
58
59 using std::cout;
60 using std::cin;
61 using std::endl;
62
63 #include "tstack1.h"
64
65 int main()
66 {
67 Stack< double > doubleStack( 5 );
68 double f = 1.1;
69 cout << "Pushing elements onto doubleStack\n";
70
71 while ( doubleStack.push( f ) ) { // success true returned
72 cout << f << ' ';
73 f += 1.1;
74 }
75
76 cout << "\nStack is full. Cannot push " << f
77 << "\n\nPopping elements from doubleStack\n";
78
79 while ( doubleStack.pop( f ) ) // success true returned
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
2000 Deitel & Associates, Inc. All rights reserved.
2000 Deitel & Associates, Inc. All rights reserved.
Outline
2. Function calls
3. Output
80 cout << f << ' ';
81
82 cout << "\nStack is empty. Cannot pop\n";
83
84 Stack< int > intStack;
85 int i = 1;
86 cout << "\nPushing elements onto intStack\n";
87
88 while ( intStack.push( i ) ) { // success true returned
89 cout << i << ' ';
90 ++i;
91 }
92
93 cout << "\nStack is full. Cannot push " << i
94 << "\n\nPopping elements from intStack\n";
95
96 while ( intStack.pop( i ) ) // success true returned
97 cout << i << ' ';
98
99 cout << "\nStack is empty. Cannot pop\n";
100 return 0;
101}
5.5 4.4 3.3 2.2 1.1
Stack is empty. Cannot pop
Pushing elements onto intStack
Popping elements from intStack
1 2 3 4 5 6 7 8 9 10
Stack is full. Cannot push 11
10 9 8 7 6 5 4 3 2 1
Stack is empty. Cannot pop
2000 Deitel & Associates, Inc. All rights reserved.
2000 Deitel & Associates, Inc. All rights reserved.
Outline
Program Output
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
2000 Deitel & Associates, Inc. All rights reserved.
2000 Deitel & Associates, Inc. All rights reserved.
12.5 Class Templates and Non-type
Parameters
• can use non-type parameters in templates
– default argument
– treated as const
• Example:
template< class T, int elements >
Stack< double, 100 > mostRecentSalesFigures;
• declares object of type Stack< double, 100>
– This may appear in the class definition:
T stackHolder[ elements ]; //array to hold stack
• creates array at compile time, rather than dynamic allocation at
execution time
2000 Deitel & Associates, Inc. All rights reserved.
2000 Deitel & Associates, Inc. All rights reserved.
12.5 Class Templates and Non-type
Parameters (II)
• Classes can be overridden
– for template class Array, define a class named
Array<myCreatedType>
– This new class overrides then class template for
myCreatedType
– The template remains for unoverriden types
2000 Deitel & Associates, Inc. All rights reserved.
2000 Deitel & Associates, Inc. All rights reserved.
12.6 Templates and Inheritance
• A class template can be derived from a template
class
• A class template can be derived from a non-
template class
• A template class can be derived from a class
template
• A non-template class can be derived from a class
template
2000 Deitel & Associates, Inc. All rights reserved.
2000 Deitel & Associates, Inc. All rights reserved.
12.7 Templates and friends
• friendships allowed between a class template and
– global function
– member function of another class
– entire class
• friend functions
– inside definition of class template X:
– friend void f1();
• f1() a friend of all template classes
– friend void f2( X< T > & );
• f2( X< int > & ) is a friend of X< int > only. The same
applies for float, double, etc.
– friend void A::f3();
• member function f3 of class A is a friend of all template classes
2000 Deitel & Associates, Inc. All rights reserved.
2000 Deitel & Associates, Inc. All rights reserved.
12.7 Templates and friends (II)
– friend void C< T >::f4( X< T > & );
• C<float>::f4( X< float> & ) is a friend of class
X<float> only
• friend classes
– friend class Y;
• every member function of Y a friend with every template class made
from X
– friend class Z<T>;
• class Z<float> a friend of class X<float>, etc.
2000 Deitel & Associates, Inc. All rights reserved.
2000 Deitel & Associates, Inc. All rights reserved.
12.8 Templates and static Members
• non-template class
– static data members shared between all objects
• template classes
– each class (int, float, etc.) has its own copy of static data
members
– static variables initialized at file scope
– each template class gets its own copy of static member
functions