1. Concordia University Department of Computer Science and Software Engineering Click to edit Master title style ADVANCED PROGRAM DESIGN WITH C++ Templates metaprogramming Joey Paquet, 2007-2014 1COMP 345 - Advanced Program Design with C++

2. Concordia University Department of Computer Science and Software Engineering Metaprogramming is about writing programs that can take programs as objects to be computed. A metaprogram is a program that can read, write, analyze, generate or change programs. metalanguage : language in which a metaprogram is written. object language : language used to express manipulated programs. If the metalanguage is also the object language, this allows to write programs that can change themselves, which is also known a reflective programming. Metaprogramming has been long part of programming languages, starting from Lisp in the early 1960s, that allowed a program to call its own interpreter to execute a string as a program, and thus allowing a program to generate an execute programs and thus invent/change its own execution. Reflective programming took a different flavor in the 1970s with the development of systems like Smalltalk, whose compiler and runtime system was written in Smalltalk itself, which allowed its runtime system to manipulate Smalltalk programs as objects. Nowadays, many “dynamic languages” allow some form of reflective programming. Metaprogramming Joey Paquet, 2007-2014 2COMP 345 - Advanced Program Design with C++

3. Concordia University Department of Computer Science and Software Engineering Template metaprogramming is a particular kind of metaprogramming technique in which templates written in a metalanguage are used by a pre-compiler to generate temporary code in a specific programming language, which is then compiled by the main compiler along with the regular source code. The template is first declared using a meta language. When it is referred to in some code in a particular context (either in regular source code or in another template), it is instantiated to this particular context of use through object code generation. The instance is then a normal object code component that can be compiled/linked with other software components written in the source language. Any time the same template is used somewhere else with the same context, the previously generated instance is used. In template metaprogramming, from the perspective of the metaprogram, the generated source code is the object language. In many implementations, the metalanguage is a hybrid language that allows the use of the object language in the metaprograms, as well as to use metaprogram instances in the object language. Template metaprogramming Joey Paquet, 2007-2014 3COMP 345 - Advanced Program Design with C++

4. Concordia University Department of Computer Science and Software Engineering C++ provides this feature, which enables the programmer to write and use templates written in a meta language that is a slight variation of C++, and that can use C++ in its definitions. C++ code with templates is thus a hybrid language. C++ templates are used to write type-abstract code that expresses a generic solution independently of some type of values used or manipulated by the solution. The most common kinds of templates are containers. For example, a stack is a container that has some behavior (top, push, pop) which is independent of the type of values stored in the stack. Writing a C++ template allows to write the logic of the code while making abstraction of some of the types involved in order to make this code applicable across different types. C++ templates Joey Paquet, 2007-2014 4COMP 345 - Advanced Program Design with C++

5. Concordia University Department of Computer Science and Software Engineering C++ templates: compilation process Joey Paquet, 2007-2014 5COMP 345 - Advanced Program Design with C++ When C++ code uses some templates, the compilation process is preceded by template metaprocessing: Reads the templates. Finds all uses of the template. Generates a concrete version of the template for each different context of use. Links uses of the template with the correct concrete version. Normal compilation is applied to the generated/altered code.

6. Concordia University Department of Computer Science and Software Engineering One might want to define a function max to return the maximum value between its two parameters, to be used as such: In order to make this work, three different functions are needed: For each type that we want max to be applicable to, we need to explicitly overload the max function. In many cases (such as this one), the implementation code remains the same and the only difference is the type of some value(s) used in the processing. C++ templates Joey Paquet, 2007-2014 6COMP 345 - Advanced Program Design with C++ void main() { cout << "max(10, 15) = " << max(10, 15) << endl; cout << "max('k', 's') = " << max('k', 's') << endl; cout << "max(10.1, 15.2) = " << max(10.1, 15.2) << endl; } int max(int a, int b) { return a > b ? a : b; } char max(char a, char b) { return a > b ? a : b; } float max(float a, float b) { return a > b ? a : b; }

7. Concordia University Department of Computer Science and Software Engineering A function template can be defined to achieve the same result: The template function declaration/definition is first registered by the compiler. Then, upon every use of the template function, the metaprocessor instantiates a version of the template depending on the context of use of the template and organizes proper linkage to each instantiated function. C++ templates Joey Paquet, 2007-2014 7COMP 345 - Advanced Program Design with C++ // template function declaration template T max(T a, T b) { return a > b ? a : b; } // uses of the function template triggers // template instances generation at compile-time void main() { cout << "max(10, 15) = " << max(10, 15) << endl; cout << "max('k', 's') = " << max('k', 's') << endl; cout << "max(10.1, 15.2) = " << max(10.1, 15.2) << endl; } // generated instances int max(int a, int b) { return a > b ? a : b; } char max(char a, char b) { return a > b ? a : b; } float max(float a, float b) { return a > b ? a : b; }

8. Concordia University Department of Computer Science and Software Engineering C++ template: template class example Joey Paquet, 2007-2014 8COMP 345 - Advanced Program Design with C++ //template class method definitions template Stack ::Stack(int s) { size = s > 0 && s < 1000 ? s : 10; top = -1; // initialize stack stackPtr = new T[size]; } // push an element onto the Stack template int Stack ::push(const T& item) { if (!isFull()) { stackPtr[++top] = item; return 1; // push successful } return 0; // push unsuccessful } // pop an element off the Stack template int Stack ::pop(T& popValue) { if (!isEmpty()) { popValue = stackPtr[top--]; return 1; // pop successful } return 0; // pop unsuccessful } // template class declaration template class Stack { public: Stack(int = 10); ~Stack() { delete[] stackPtr; } int push(const T&); int pop(T&); int isEmpty()const { return top == -1; } int isFull() const { return top == size - 1; } private: int size; int top; T* stackPtr; }; // use of template class // triggers template instantiation void main() { Stack fs(5); float f = 1.1; while (fs.push(f)) { cout << f << ' '; f += 1.1; } while (fs.pop(f)) cout << f << ' '; Stack is; int i = 1.1; while (is.push(i)) { cout << i << ' '; i += 1; } while (is.pop(i)) cout << i << ' '; }

9. Concordia University Department of Computer Science and Software Engineering Operators can also be defined as templates: Templates operators can also be declared as fiends of classes, whether they are template classes or not. C++ templates: template operator Joey Paquet, 2007-2014 9COMP 345 - Advanced Program Design with C++ template ostream& operator stack) { int i; while (stack.pop(i)) output << i << ' '; return output; }

10. Concordia University Department of Computer Science and Software Engineering A great limitation of templates is that their applicability across different types is bound by the meaningfulness of the code that they use for all types that they will eventually be used for. Take our previous example max function template, which we might later want to use for strings: Here the problem is that applying the > operator on a char* (type of "Foo" and "Bar" ) compares the pointer values, not the strings that they point to, leading to incorrect result. We need to redefine the code for the implementation of max to use a comparison operation/function that also applies to char*. However, such an operation might not exist, leading us to write type-dependent code. Template specialization Joey Paquet, 2007-2014 10COMP 345 - Advanced Program Design with C++ template T max(T a, T b) { return a > b ? a : b; } void main() { cout << "max(10, 15) = " << max(10, 15) << endl; cout << "max('k', 's') = " << max('k', 's') << endl; cout << "max(10.1, 15.2) = " << max(10.1, 15.2) << endl; cout << "max("Foo", "Bar") = " << max("Foo", "Bar") << endl; }

11. Concordia University Department of Computer Science and Software Engineering Alternately, we can also use the notion of template specialisation to provide an alternate implementation for a specific instance of the template: This defines a specific instance of the function template max that is applicable when both parameters are of type char*. Template specialization Joey Paquet, 2007-2014 11COMP 345 - Advanced Program Design with C++ template <> char* max(char* a, char* b) { return strcmp(a, b) > 0 ? a : b; }

12. Concordia University Department of Computer Science and Software Engineering The same concept can be applied to template classes This defines a specific instance of the template class Formatter that is applicable when the parameters is of type char*. Template specialization Joey Paquet, 2007-2014 12COMP 345 - Advanced Program Design with C++ // Template class declaration and definition template class Formatter { T* m_t; public: Formatter(T* t) : m_t(t) { } void print() { cout << *m_t << endl; } }; // Specialization of template class // for type char* template<> class Formatter { char** m_t; public: Formatter(char** t) : m_t(t) { } void print() { cout << "Char: " << **m_t << endl; } }; int main() { int i = 157; // Use the generic template with int as the argument. Formatter formatter1(&i); char str[10] = "string1"; char* str1 = str; // Use the specialized template. Formatter formatter2(&str1); formatter1.print(); // 157 formatter2.print(); // Char value : s }

13. Concordia University Department of Computer Science and Software Engineering Each template class instance has its own copies of any static variables or members. Here, X has its own static member int s, which is shared by all instances of the type X. X has its own static member char* s, which is shared by all instances of the type X. Static data members are initialized outside of the class declaration (as are static members of regular classes) using the following syntax: Each template function instance has its own copy of any static local variables declared in a function template: C++ templates and static data members and local variables Joey Paquet, 2007-2014 13COMP 345 - Advanced Program Design with C++ template class X { public: static T s ; }; int main() { X xi ; X xc ; } template <> int X ::s = 3 ; template <> char* X ::s = "Hello" ; int main() { X xi ; cout << "xi.s = " << xi.s << endl ; X xc ; cout << "xc.s = " << xc.s << endl ; return 0 ; } template void f(T t) { static T s = 0; s = t ; cout << "s = " << s << endl ; } int main() { f(10) ; f("Hello") ; return 0 ; }

14. Concordia University Department of Computer Science and Software Engineering Templates are not classes or functions, they are a declaration that is used to generate classes when an instantiation is required. This poses the additional requirement that all template declarations should be available to any compilation unit that is using it. Let us take the Stack template example. According to standard class definition practice, we have: Stack.h that contains the declaration of the Stack template. Stack.cpp that contains the declarations of the member functions of the Stack class, which are themselves function templates. StackDriver.cpp that declares two variable of type Stack and Stack. Each of these declarations trigger the compile-time generation of two specific Stack classes. As we have, according to standard practice, a #include “Stack.h” in StackDriver.cpp, the declaration of the Stack template is available at compile time. However, StackDriver.cpp calls the functions push() and pop() on the stack objects, which triggers the compile-time generation of two specific Stack.push() and Stack.pop(). As the declaration of these templates are in Stack.cpp (a different compilation unit), compilation fails. Templates and separate compilation Joey Paquet, 2007-2014 14COMP 345 - Advanced Program Design with C++

15. Concordia University Department of Computer Science and Software Engineering Templates and separate compilation Joey Paquet, 2007-2014 15COMP 345 - Advanced Program Design with C++ // Stack.h // template class declaration template class Stack { public: Stack(int = 10); ~Stack() { delete[] stackPtr; } int push(const T&); int pop(T&); int isEmpty()const { return top == -1; } int isFull() const { return top == size - 1; } private: int size; int top; T* stackPtr; }; // StackDriver.cpp #include "Stack.h" void main() { Stack fs(5); float f = 1.1; while (fs.push(f)) { cout << f << ' '; f += 1.1; } while (fs.pop(f)) cout << f << ' '; Stack is; int i = 1.1; while (is.push(i)) { cout << i << ' '; i += 1; } while (is.pop(i)) cout << i << ' '; } Stack.cpp //template class method definitions #include "Stack.h" template Stack ::Stack(int s) { size = s > 0 && s < 1000 ? s : 10; top = -1; // initialize stack stackPtr = new T[size]; } // push an element onto the Stack template int Stack ::push(const T& item) { if (!isFull()) { stackPtr[++top] = item; return 1; // push successful } return 0; // push unsuccessful } // pop an element off the Stack template int Stack ::pop(T& popValue) { if (!isEmpty()) { popValue = stackPtr[top--]; return 1; // pop successful } return 0; // pop unsuccessful }

16. Concordia University Department of Computer Science and Software Engineering This means that each compilation unit that is making use of a template must have the template declarations available internally. If a template class is declared separately from its template methods, both need to be united in order to be used across different compilation units. There are different ways to achieve that: Declare all methods as inline, forcing everything into the header file. Put all methods’ definitions in the header file with the template class declaration. Other related solutions: Put some explicit template instantiation declarations at the end of the Stack.cpp file, e.g. This will force the generation of these specific classes. However, only those will be available for linkage. Put a #include “Stack.cpp” at the end of Stack.h, forcing the implementation of Stack.cpp into whatever compilation unit that does a #include “Stack.h”. This is against the separate compilation principle. Templates and separate compilation Joey Paquet, 2007-2014 16COMP 345 - Advanced Program Design with C++ template class Stack ;

17. Concordia University Department of Computer Science and Software Engineering While Java generics syntactically look like C++ templates and are used to achieve the same purpose, it is important to note that they are not implemented using the same concepts, nor do they provide the same programming features. Java generics simply provide compile-time type safety and eliminate the need for explicit casts when using type-abstract types and algorithms. Java generics use a technique known as type erasure, and the compiler keeps track of the generic definitions internally, hence using the same class definition at compile/run time. A C++ template on the other hand use template metaprogramming, by which whenever a template is instantiated with a new type parameter, the entire code for the template is generated adapted to the type parameter and then compiled, hence having several definitions for each template instance at run time. C++ templates vs. Java generics Joey Paquet, 2006-2014 17COMP 345 - Advanced Program Design with C++

18. Concordia University Department of Computer Science and Software Engineering In Java, a class or method that is defined with a parameter for a type is called a generic class/method or a parameterized class/method: For classes, the type parameter is included in angular brackets after the class name in the class definition heading. For methods, the type parameter is included before the method definition. Methods can define/use additional type parameters additional to their class’ type parameters. The type parameters are to be used like other types used in the definition of a class/method. When a generic class is used, the specific type to be plugged in is provided in angular brackets. When a generic method is called, its call’s parameter/return type are plugged in. C++ templates vs. Java generics Joey Paquet, 2006-2014 18COMP 345 - Advanced Program Design with C++ /** * Generic class that defines a wrapper class around a single * element of a generic type. */ public class Box { private T t; public void set(T t) { this.t = t; } public T get() { return t; } public void inspect(){ System.out.println("T: " + t.getClass().getName()); } /** * Generic method that uses both the generic type of the class * it belongs to, as well as an additional generic type that is * bound to the Number type. */ public void inspectWithAdditionalType(U u){ System.out.println("T: " + t.getClass().getName()); System.out.println("U: " + u.getClass().getName()); } public static void main(String[] args) { Box integerBox = new Box (); integerBox.set(new Integer(10)); integerBox.inspect(); integerBox.inspectWithAdditionalType("Hello world"); Integer i = integerBox.get(); }

19. Concordia University Department of Computer Science and Software Engineering In Java, then the class is compiled, type erasure is applied on the type parameter for each specific use of the generic class or method: Every occurrence of the type parameter is replaced with the highest type applicable to the type parameter. If a type bound was specified, this type is applied. If no type bound was specified, Object is used. If a value is extracted from a generic class or returned from a generic method that is of the type parameter type, its type is automatically casted to the type used at instantiation. C++ templates vs. Java generics Joey Paquet, 2006-2014 19COMP 345 - Advanced Program Design with C++ /** * Generic class that defines a wrapper class around a single * element of a generic type. */ public class Box { private Number t; public void set(Number t) { this.t = t; } public Number get() { return t; } public void inspect(){ System.out.println("T: " + t.getClass().getName()); } /** * Generic method that uses both the generic type of the class * it belongs to, as well as an additional generic type that is * bound to the Number type. * */ public void inspectWithAdditionalType(Object u){ System.out.println("T: " + t.getClass().getName()); System.out.println("U: " + u.getClass().getName()); } public static void main(String[] args) { Box integerBox = new Box(); integerBox.set(new Integer(10)); integerBox.inspect(); integerBox.inspectWithAdditionalType("Hello world"); Integer i = integerBox.get(); }

20. Concordia University Department of Computer Science and Software Engineering Using C++ templates makes compilation time slower, especially if a lot of different template instantiations are required, or if template declarations are using other template declarations, or are declared recursively. May result in code bloat if explicit template instantiation is overused. Due to the way templates are processed, using templates forces to reconsider the practice of separating class/function declarations in header files and their implementation in implementation files. C++ templates are fundamentally a different concept than Java/C# generic classes. There is no relationship between two different template instantiated with classes that themselves have an inheritance relationship, e.g. if class B is a subclass of class A, Stack is not a subclass of Stack. C++ templates: facts Joey Paquet, 2007-2014 20COMP 345 - Advanced Program Design with C++

21. Concordia University Department of Computer Science and Software Engineering http://users.cis.fiu.edu/~weiss/Deltoid/vcstl/templates http://stackoverflow.com/questions/495021/why-can-templates-only-be- implemented-in-the-header-file http://stackoverflow.com/questions/495021/why-can-templates-only-be- implemented-in-the-header-file References Joey Paquet, 2007-2014 21COMP 345 - Advanced Program Design with C++