1. 1 Object-Oriented Programming -- Using C++ Andres, Wen-Yuan Liao Department of Computer Science and Engineering De Lin Institute of Technology andres@dlit.edu.tw http://cse.dlit.edu.tw/~andres

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

3. 3 11.1 Introduction Templates –Function templates Specify entire range of related (overloaded) functions with a single code segment –Function-template specializations –Class templates Specify entire range of related classes with a single code segment –Class-template specializations

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

5. 5 11.2 Function Templates (3.21) Example template // or template T square( T value1 ) { return value1 * value1; } –T is a formal type, used as parameter type Above function returns variable of same type as parameter –In function call, T replaced by real type If int, all T 's become int s int square(int value1 ) { return value1 * value1; } If double, all T 's become double s double square(double value1 ) { return value1 * value1; }

6. 6 1 // Fig. 3.27: fig03_27.cpp 10 template 11 T maximum( T value1, T value2, T value3 ) { 13 T max = value1; 15 if ( value2 > max ) 16 max = value2; 18 if ( value3 > max ) 19 max = value3; 21 return max; 23 } 25 int main() { 28 int int1, int2, int3; 31 cin >> int1 >> int2 >> int3; 34 cout << maximum( int1, int2, int3 ); 38 double double1, double2, double3; 41 cin >> double1 >> double2 >> double3; 44 cout << maximum( double1, double2, double3 ); 48 char char1, char2, char3; 51 cin >> char1 >> char2 >> char3; 54 cout << maximum( char1, char2, char3 ) 56 << endl; 58 return 0; 60 } int maximum( int value1, int value2, int value3 ) { int max = value1; …… } double maximum( double value1, double value2, double value3 ) { double max = value1; …… } char maximum( char value1, char value2, char value3 ) { char max = value1; …… }

7. 7 Input three integer values: 1 2 3 The maximum integer value is: 3 Input three double values: 3.3 2.2 1.1 The maximum double value is: 3.3 Input three characters: A C B The maximum character value is: C

8. 8 11.2 Function Templates Function-template definitions –Keyword template –List formal type parameters in angle brackets ( ) Each parameter preceded by keyword class or typename –class and typename interchangeable template Specify types of –Arguments to function –Return type of function –Variables within function

9. 9 fig11_01.cpp (1 of 2) 1 // Fig. 11.1: fig11_01.cpp 9 template 10 void printArray( const T *array, const int count ) { 12 for ( int i = 0; i < count; i++ ) 13 cout << array[ i ] << " "; 15 cout << endl; 17 } 19 int main() { 21 const int aCount = 5; 22 const int bCount = 7; 23 const int cCount = 6; 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"; 29 cout << "Array a contains:" << endl; 32 printArray( a, aCount ); 34 cout << "Array b contains:" << endl; 37 printArray( b, bCount ); 39 cout << "Array c contains:" << endl; 42 printArray( c, cCount ); 44 return 0; 46 } void printArray( const int *array, const int count ) { void printArray( const double *array, const int count ) { void printArray( const char *array, const int count ) { 1 2 3 4 5 a[0] a[1] a[2] a[3] a[4] 1.1 2.2 3.3 4.4 5.5 6.6 7.7 b[6] b[0] b[1] b[2] b[3] b[5] b[4] H E L L O \0 c[0] c[1] c[2] c[3] c[5] c[4]

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

11. 11 11.3 Overloading Function Templates Related function-template specializations –Same name Compiler uses overloading resolution Function template overloading template void printArray( const T *array, const int count ) –Function templates with same name Different parameters template int printArray( T const * const array, int size, int lowSubscript, int highSubscript )

12. 12 11.3 Overloading Function Templates Function template overloading –Non-template functions with same name Different function arguments void printArray( char const * const stringArray[], int size ) –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

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

14. 14 tstack1.h (1 of 4) 1 // Fig. 11.2: tstack1.h 6 template 7 class Stack { 9 public: 10 Stack( int = 10 ); 13 ~Stack() { 15 delete [] stackPtr; 17 } 19 bool push( const T& ); 20 bool pop( T& ); 23 bool isEmpty() const { 25 return top == -1; 27 } 30 bool isFull() const { 32 return top == size - 1; 34 } 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 41 }; class Stack + Stack( int = 10 ); + ~Stack() + bool push( const T& ); + bool pop( T& ); + bool isEmpty() const + bool isFull() const - int size; - int top; - T *stackPtr; [9] [0] [1] [2] [3] [4] [5] [6] [7] [8] T

15. 15 44 template 45 Stack ::Stack( int s ) { 47 size = s > 0 ? s : 10; 48 top = -1; // Stack initially empty 49 stackPtr = new T[ size ]; 51 } 55 template 56 bool Stack ::push( const T &pushValue ) { 58 if ( !isFull() ) { 59 stackPtr[ ++top ] = pushValue; 60 return true; 62 } 64 return false; 66 } 70 template 71 bool Stack ::pop( T &popValue ) { 73 if ( !isEmpty() ) { 74 popValue = stackPtr[ top-- ]; // remove item from Stack 75 return true; 77 } 79 return false; 81 } class Stack + Stack( int = 10 ); + ~Stack() + bool push( const T& ); + bool pop( T& ); + bool isEmpty() const + bool isFull() const - int size; - int top; - T *stackPtr; [9] [0] [1] [2] [3] [4] [5] [6] [7] [8] T

16. 16 1 // Fig. 11.3: fig11_03.cpp 9 #include "tstack1.h" 11 int main() { 13 Stack doubleStack( 5 ); 14 double doubleValue = 1.1; 18 while ( doubleStack.push( doubleValue ) ) { 19 cout << doubleValue << ' '; 20 doubleValue += 1.1; 22 } 24 cout << "\nStack is full. Cannot push " << doubleValue 25 << "\n\nPopping elements from doubleStack\n"; 27 while ( doubleStack.pop( doubleValue ) ) 28 cout << doubleValue << ' '; 30 cout << "\nStack is empty. Cannot pop\n"; 32 Stack intStack; 33 int intValue = 1; 34 cout << "\nPushing elements onto intStack\n"; 36 while ( intStack.push( intValue ) ) { 37 cout << intValue << ' '; 38 ++intValue; 40 } 1.1 2.2 3.3 4.4 5.510 1 2 3 4 5 6 7 8 9 Stack doubleStack - size = 5; - top = -1; - double * stackPtr; Stack intStack - size = 10; - top = -1; - int * stackPtr; [9] [0] [1] [2] [3] [4] [5] [6] [7] [8] [0] [1] [2] [3] [4]

17. 17 fig11_03.cpp (3 of 3) fig11_03.cpp output (1 of 1) 42 cout << "\nStack is full. Cannot push " << intValue 43 << "\n\nPopping elements from intStack\n"; 45 while ( intStack.pop( intValue ) ) 46 cout << intValue << ' '; 48 cout << "\nStack is empty. Cannot pop\n"; 50 return 0; 51 52 } 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

18. 18 1 // Fig. 11.4: fig11_04.cpp 10 #include "tstack1.h" 13 template 14 void testStack( 15 Stack &theStack, // reference to Stack 16 T value, // initial value to push 17 T increment, // increment for subsequent values 18 const char *stackName ) { 20 cout << "\nPushing elements onto " << stackName << '\n'; 22 while ( theStack.push( value ) ) { 23 cout << value << ' '; 24 value += increment; 26 } 28 cout << "\nStack is full. Cannot push " << value 29 << "\n\nPopping elements from " << stackName << '\n'; 31 while ( theStack.pop( value ) ) 32 cout << value << ' '; 34 cout << "\nStack is empty. Cannot pop\n"; 36 } class Stack + Stack( int = 10 ); + ~Stack() + bool push( const T& ); + bool pop( T& ); + bool isEmpty() const + bool isFull() const - int size; - int top; - T *stackPtr; theStack T

19. 19 38 int main() { 40 Stack doubleStack( 5 ); 41 Stack intStack; 43 testStack( doubleStack, 1.1, 1.1, "doubleStack" ); 44 testStack( intStack, 1, 1, "intStack" ); 46 return 0; 48 } 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 1.1 2.2 3.3 4.4 5.510 1 2 3 4 5 6 7 8 9 Stack doubleStack - size = 5; - top = -1; - double * stackPtr; Stack intStack - size = 10; - top = -1; - int * stackPtr; [9] [0] [1] [2] [3] [4] [5] [6] [7] [8] [0] [1] [2] [3] [4] void testStack( Stack &theStack, double value, double increment, const char *stackName ) void testStack( Stack &theStack, int value, int increment, const char *stackName ) theStack

20. 20 11.5 Class Templates and Nontype Parameters Class templates –Nontype parameters Default arguments Treated as consts Example: template Stack mostRecentSalesFigures; –Declares object of type Stack –Type parameter Default type –Example: template

21. 21 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 TTT

22. 22 11.7 Templates and Friends Friendships between class template and –Global function –Member function of another class –Entire class

23. 23 11.7 Templates and Friends template class X { friend void f1(); friend void f2( X & ); friend void A::f4(); friend void C ::f5( X & ); friend class Y; friend class Z ; };

24. 24 11.7 Templates and Friends friend functions –Inside definition of template class X friend void f1(); –f1() friend of all class-template specializations friend void f2( X & ); –f2( X & ) friend of X only, f2( X & ) friend of X only, … friend void A::f4(); –Member function f4 of class A friend of all class-template specializations

25. 25 11.7 Templates and Friends friend functions –Inside definition of template class X friend void C ::f5( X & ); –Member function C ::f5( X & ) friend of class X only friend classes –Inside definition of template class X friend class Y; –Every member function of Y friend of every class-template specialization friend class Z ; –class Z friend of class-template specialization X, etc.

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

27. 27 Programming Homework 10.14 11.7 Deadline: 12/15