Semantics of C++ Hauptseminar im Wintersemester 2009/10 Templates

Transcription

1 Semantics of C++ Hauptseminar im Wintersemester 2009/10 Templates Sebastian Wild Technische Universität München Abstract In this work we will discuss about templates in C++, especially their usage and the handling by the compiler. 1 Introduction Templates are a powerful tool, that gives us the possibility to create algorithms and data structures which are independent of a special data type. The Standard Template Library (STL) and also the boost library are built up using templates. Furthermore, templates gives us a Turing complete language feature which we can use to program whole algorithms. Those will be executed during the compilation process and therefore do not require any runtime, because the solution is already present. In this work, we will give a general overview about how to use templates in the first section. In the second part we will see how the compiler handles templates and in the last part we will give an introduction what will change in the new C++ standard. 2 Templates 2.1 Function Templates With Function templates we can create functions which can perform an operation with more than one type. That gives us the advantage that we do not have to write code multiple times. Each time we use the function, we just tell the function which data type we use. A function template is defined by placing the keyword template followed by <typename wildcard > in front of the function definition. The wildcard has to be placed at every position where the type should be variable, that means if the 1

2 return type is variable it has to be placed as the return type and for the types of the parameters as well as the types of the variables inside of the function. 1 template <typename T> 2 T f u n c t i o n (T var1, T var2 ) {... } It is also possible to use several variable data types in one template function. 1 template <typename T, typename U, typename V> 2 T f u n c t i o n (T var1, U var2, V var ) {... } Instead of using the keyword typename, one can also use class. Some programmers use typename if they want to clarify that this function just works with basic fundamental data types and class if it works with classes also. 1 template <class T> 2 T f u n c t i o n (T var1, T var2 ) {... } Using those function templates is pretty easy, since the compiler chooses the type to use by looking at the parameter which we assign to the function. Let us see how this works at an example function which will just add up two numbers and returns the solution. You should be aware of the fact, that the type of the parameter you will assign to the function must have a summation operator. 1 #include <iostream > 2 using namespace std ; 4 template <class T> 5 T add (T a, T b ) { 6 return a + b ; 7 } 8 9 int main ( int argc, char argv ) { 10 cout << add ( 5, 6) << endl ; // r e t u r n s cout << add (. 5, 2. 6 ) << endl ; // r e t u r n s return 0 ; 14 } It is also possible to write a function which works for several types without templates, but as we will see in this example it is not that elegant. This is an implementation of the shell sort algorithm which is introduced in The art of programming. Volume : Searching and Sorting by Knuth. [] 1 typedef int ( CFT) ( const void, const void ) ; 2 void s s o r t ( void base, s i z e t n, s i z e t sz, CFT cmp) 2

3 4 { 5 for ( int gap = n / 2 ; 0 < gap ; gap /= 2 ) 6 for ( int i = gap ; i < n ; i++ ) 7 for ( int j = i gap ; 0 <= j ; j = gap ) { 8 char b = static cast <char >( base ) ; 9 char pj = b + j s z ; 10 char pjg = b + ( j + gap ) s z ; 11 i f ( cmp( pjg, pj ) < 0 ) { 12 for ( int k = 0 ; k < s z ; k++ ) { 1 char temp = pj [ k ] ; 14 pj [ k ] = pjg [ k ] ; 15 pjg [ k ] = temp ; 16 } 17 } 18 } 19 } 1 template<class T> void s o r t ( vector <T>& v ) 2 { const s i z e t n = v. s i z e ( ) ; 4 for ( int gap = n / 2 ; 0 < gap ; gap /= 2 ) 5 for ( int i = gap ; i < n ; i++ ) 6 for ( int j = i gap ; 0 <= j ; j = gap ) { 7 i f ( v [ j + gap ] < v [ j ] ) { 8 T temp = v [ j ] ; 9 v [ j ] = v [ j + gap ] ; 10 v [ j + gap ] = temp ; 11 } 12 } 1 } 2.2 Class Templates To create a data structure with attributes and methods, we usually use a class in C++. For example, if we want to have a container such as a linked list we could only store items with a specific data type in it if we would not have templates. The whole Standard Template Library is build up on the concept of templates as the name implies. The definition of a template class is basically the same as with the template functions, we just exchange the function definition with the class definition. 1 template <class T> 2 class ClassTemplate {... 4 } ; As usual we can create an instance of a class on the stack or on the heap we just have to tell the compiler which type we want to use in the class. Let us look at both types of creating an instance of a template class at an example.

4 1 template <typename T> 2 class Add { public : 4 T sum(t a, T b ) ; 5 } ; 6 7 template <typename T> 8 Add<T>::sum(T a, T b ) { 9 return a + b ; 10 } int main ( int argc, char argv ) { 1 Add<int> s1 ; 14 cout << s1. sum ( 5, 6) ; Add<double> s2 ; 17 cout << s2. sum (. 5, 2. 6 ) ; Add<int> s = new Add<int >() ; 20 cout << s1 >sum ( 5, 6) << endl ; Add<double> s4 = new Add<double>; 2 cout << s4 >sum (. 5, 2. 6 ) << endl ; return 0 ; 26 } 2. Specialization Let us look at the following example [2]: 1 template <typename T> 2 class CAdd { public : 4 CAdd(T array [ ], unsigned n ) : m sum ( 0 ) { 5 for ( unsigned i = 0 ; i < n ; i++ ) 6 m sum += array [ i ] ; 7 } 8 9 void p r i n t ( char t e x t ) { cout << t e x t << m sum << endl ; } 10 private : 11 T m sum ; 12 } ; 1 14 int main ( int argc, char argv ) { 15 int ganz [ 5 ] = {10, 20, 0, 40, 5 0 } ; 16 double gebr [ 4 ] = {. 1 4, , 7. 0, 2. 0 } ; 17 char s t r [ 4 ] = { Ich, bin, nun, e i n S t r i n g } ; CAdd<int> isum ( ganz, 5) ; 20 CAdd<double> dsum( gebr, 4) ; 21 CAdd<char > ssum ( s t r, 4) ; // Error 22 } 4

5 We can use this template with different types, but why can we not use this one with char*? The answer is at line 6 of the example above. The char* does not have a + operator. To solve this problem there are two different possibilities. One would be to write a new class called CAddString or we use template specialization. That means, we have to write the class again, but still as a template with the specific type and for that matter, we do not have to change the way we create an instance of the class. This is also possible with function templates. It works the same way as class templates do as you can see in the following example []: 1 template <class T> 2 bool l e s s (T a, T b ) { return a < b ; } 4 template <> 5 bool l e s s <const char > ( const char a, const char b ) { return strcmp ( a, b ) < 0 ; } 1 template <> 2 class CAdd<char > { public : 4 CAdd<char >(char array [ ], unsigned n ) { 5 m sum = new char [ ] ; 6 m sum = 0 ; 7 for ( unsigned i = 0 ; i < n ; i++ ) 8 s t r c a t (m sum, array [ i ] ) ; 9 } void p r i n t ( char t e x t ) { cout << t e x t << m sum << endl ; } 12 private : 1 char m sum ; 14 } ; As we can see in this example for the specialization, there are a few differences and also some things we have to keep in mind. Write template <> in front of the class Every time we use the class name we have to write the specialized type after it, e.g. Class declaration: class CAdd < char* >... Constructor: CAdd < char* > (... )... Desctructor: CAdd < char* > ()... Replace all types of the parameters through the special type A specialized template has to be defined after the general class template has been defined 5

6 There is also another type of specialization, the partial specialization. The difference here is, that we do not specialize the class or function for a concrete type. Instead we specialize the template for a certain class of data types, e.g. we specialize it for every pointer type. 1 class CAdd<T > { 2 public : CAdd(T array [ ], unsigned n ) : m sum ( 0 ) { 4 for ( unsigned i = 0 ; i < n ; i++ ) 5 m sum += array [ i ] ; 6 } 7 8 void p r i n t ( char t e x t ) { cout << t e x t << m sum << endl ; } 9 private : 10 T m sum ; 11 } ; In the end, we have first of all the general template which we can then specialize for a certain group of types (e.g. pointers) or we specialize it for a certain data type (char*, void*,...). That gives as a wide range of possibilities to work with templates. Compiler output In this section we want to look at the templates from another point of view, the compilers. To do this, we want to look at the assembly code of the examples which perform the same operation. We write the class with int and double as types and then we also have the template class, which we will instantiate with int as type. First of all the three examples in C++: 1 #include <iostream > 2 using namespace std ; 4 template <typename T> 5 class Add 6 { 7 public : 8 T sum(t a, T b ) 9 { 10 return a + b ; 11 } 12 } ; 1 14 int main ( int argc, char argv ) 15 { 16 Add<int> o1 ; cout << o1. sum ( 5, 6) << endl ; Add<int> o2 = new Add<int >() ; 6

7 21 22 cout << o2 >sum ( 5, 6) << endl ; 2 24 delete o2 ; return 0 ; 27 } 1 #include <iostream > 2 using namespace std ; 4 class Add 5 { 6 public : 7 double sum( double a, double b ) 8 { 9 return a + b ; 10 } 11 } ; 12 1 int main ( int argc, char argv ) 14 { 15 Add o1 ; cout << o1. sum ( 5. 4, 6. ) << endl ; Add o2 = new Add ( ) ; cout << o2 >sum ( 5. 2, 6. 7 ) << endl ; 22 2 delete o2 ; return 0 ; 26 } Now we want to analyze some parts of the assembly, which is produced by the compiler. As we will see in the first two examples, there is no difference between a class written for a specific type or a template class, which is then instantiated with the same type. For this we look at the assembly code of the sum function: 1?sum@Add@@QAEHHH@Z PROC ; Add : : sum, COMDAT 2 ; t h i s \$ = ecx 4 ; 8 : { 5 6 push ebp 7 mov ebp, esp 8 sub esp, 204 ; cch 9 push ebx 10 push e s i 11 push e d i 12 push ecx 1 l e a edi, DWORD PTR [ ebp 204] 7

8 14 mov ecx, 51 ; H 15 mov eax, ; cccccccch 16 rep s t o s d 17 pop ecx 18 mov DWORD PTR t h i s \$ [ ebp ], ecx ; 9 : return a + b ; mov eax, DWORD PTR a \$ [ ebp ] 2 add eax, DWORD PTR b \$ [ ebp ] ; 10 : } pop e d i 28 pop e s i 29 pop ebx 0 mov esp, ebp 1 pop ebp 2 r e t 8?sum@Add@@QAEHHH@Z ENDP ; Add : : sum 1?sum@?\$Add@H@@QAEHHH@Z PROC ; Add<int >:: sum, COMDAT 2 ; t h i s \$ = ecx 4 ; 9 : { 5 6 push ebp 7 mov ebp, esp 8 sub esp, 204 ; cch 9 push ebx 10 push e s i 11 push e d i 12 push ecx 1 l e a edi, DWORD PTR [ ebp 204] 14 mov ecx, 51 ; H 15 mov eax, ; cccccccch 16 rep s t o s d 17 pop ecx 18 mov DWORD PTR t h i s \$ [ ebp ], ecx ; 10 : return a + b ; mov eax, DWORD PTR a \$ [ ebp ] 2 add eax, DWORD PTR b \$ [ ebp ] ; 11 : } pop e d i 28 pop e s i 29 pop ebx 0 mov esp, ebp 1 pop ebp 2 r e t 8?sum@?\$Add@H@@QAEHHH@Z ENDP ; Add<int >:: sum 8

9 If we compare those, there is no difference in the basic code. That is how the compiler handles templates. For every type we use the template with it exactly writes the code down for the special type, which we can see in these two examples for the int class and the template instantiated with the type int. If we compare it to the compiler output for the special type double, it is different in the way, that we would have for the double class. PROC ; Add<double >:: sum, COMDAT 2 ; t h i s \$ = ecx 4 ; 9 : { 5 6 push ebp 7 mov ebp, esp 8 sub esp, 204 ; cch 9 push ebx 10 push e s i 11 push e d i 12 push ecx 1 l e a edi, DWORD PTR [ ebp 204] 14 mov ecx, 51 ; H 15 mov eax, ; cccccccch 16 rep s t o s d 17 pop ecx 18 mov DWORD PTR t h i s \$ [ ebp ], ecx ; 10 : return a + b ; f l d QWORD PTR a \$ [ ebp ] ; F l o a t i n g Point I n s t r u c t i o n s 2 fadd QWORD PTR b \$ [ ebp ] ; 11 : } pop e d i 28 pop e s i 29 pop ebx 0 mov esp, ebp 1 pop ebp 2 r e t 16 ; H?sum@?\$Add@N@@QAENNN@Z ENDP ; Add<double >:: sum If we compare the rest of the assembly we will see that, besides some differences in the names of procedures, there are no differences at all. That means for the compiler that he produces the same code and, in the case of the template, just replaces the variable data type with the concrete one. 4 Conclusion Templates are a powerful tool that gives us a wide range of possibilities to implement data type independent data structures and algorithms. But there are also some restrictions, e.g. that we can not implement them in precompiled 9

10 libraries such as.dll,.lib,.a,.so. The most changes in the new C++ standard are that parts of the boost library will be included in the standard library and those data structures and algorithms are implemented with templates. There is just one additional feature to mention and those are variadic templates. Those give us the possibility to write templates where we can decide how many template parameters we use at the time we create an instance of a class. That can be between zero an many parameters. We can observe this in the following example [1]: 1 template<class... Types> struct Tuple { } ; 2 Tuple<> t0 ; // Types c o n t a i n s no arguments 4 Tuple<int> t1 ; // Types c o n t a i n s one argument : i n t 5 Tuple<int, float > t2 ; // Types c o n t a i n s two arguments : i n t and f l o a t This feature gives us new possibilities like writing a printf like function with templates instead of a multiple parameter list of a function. In the end we should always think about using templates when we design new data structures or algorithms since it can keep us from writing the same code over and over again and with the use of templates we can also calculate some procedures during the compilation process. References [1] Peter Becker. Working draft, standard for programming language c++. Technical report, ISO/IEC, [2] Helmut Herold, Michael Klar, and Susanne Klar. C++, UML und Design Patterns. Addison-Wesley, [] Bjarne Stroustrup. Die C++ Programmiersprache. Addison-Wesley,