Advanced Program Design with C++

1. Advanced Program Design with C++ Templates metaprogramming Joey Paquet, 2007-2018

2. Metaprogramming • Metaprogramming is about writing programs that can take programs as data 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 (through the eval() function), 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 data objects. • Nowadays, many “dynamic languages” allow some form of reflective programming. Joey Paquet, 2007-2018

3. Template metaprogramming • Template metaprogramming is a particular kind of metaprogramming technique in which templates written in a metalanguage are used by a pre-compiler to generate intermediate 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 generated in the object language. • In many implementations, such as C++, 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. Joey Paquet, 2007-2018

4. C++ templates • C++ provides this feature, which enables the programmer to write and use C++templates written in a meta language that is a slight variation of C++, and that can use C++ in their definitions. C++ code with templates is thus written in 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 implementation. • The most common kinds of templates are containers, such as those implemented in the Standard Templates Library (STL). • For example, a stack is a container that has some behavior (top, push, pop) which is common across and 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. Joey Paquet, 2007-2018

5. C++ templates: compilation process • 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. Joey Paquet, 2007-2018

6. C++ templates • 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. 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(inta, intb) { returna > b ? a : b; } char max(chara, charb) { returna > b ? a : b; } float max(floata, floatb) { returna > b ? a : b; } Joey Paquet, 2007-2018

7. C++ templates • 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. // template function declaration template <typenameT> T max(Ta, Tb) { returna > 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(inta, intb) { returna > b ? a : b; } char max(chara, charb) { returna > b ? a : b; } float max(floata, floatb) { returna > b ? a : b; } Joey Paquet, 2007-2018

8. C++ template: template class example // template class declaration template <typenameT> classStack { public: Stack(int = 10); ~Stack() { delete[] stackPtr; } int push(constT&); int pop(T&); intisEmpty()const { return top == -1; } intisFull() const { return top == size - 1; } private: int size; int top; T* stackPtr; }; //template class method definitions template <typenameT> Stack<T>::Stack(ints) { size = s > 0 && s < 1000 ? s : 10; top = -1; // initialize stack stackPtr = newT[size]; } // push an element onto the Stack template <typenameT> intStack<T>::push(constT& item) { if (!isFull()) { stackPtr[++top] = item; return 1; // push successful } return 0; // push unsuccessful } // pop an element off the Stack template <typenameT> intStack<T>::pop(T& popValue) { if (!isEmpty()) { popValue = stackPtr[top--]; return 1; // pop successful } return 0; // pop unsuccessful } // use of template class // triggers template instantiation void main() { Stack<float> fs(5); float f = 1.1; while (fs.push(f)) { cout << f << ' '; f += 1.1; } while (fs.pop(f)) cout << f << ' '; Stack<int> is; inti = 1.1; while (is.push(i)) { cout << i << ' '; i += 1; } while (is.pop(i)) cout << i << ' '; } Joey Paquet, 2007-2018

9. C++ templates: template operator • Operators can also be defined as templates: • Template operators can also be declared as fiends of classes, whether they are template classes or not. template <typenameT> ostream& operator<<( ostream& output, Stack<T> stack) { inti; while (stack.pop(i)) output << i << ' '; returnoutput; } Joey Paquet, 2007-2018

10. Explicit template specialization • 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 <typenameT> T max(Ta, Tb) { returna > 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; } Joey Paquet, 2007-2018

11. Explicit template specialization • Alternately, we can also use the notion of explicit 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 <> char* max(char* a, char* b) { returnstrcmp(a, b) > 0 ? a : b; } Joey Paquet, 2007-2018

12. Explicit template specialization • 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 class declaration and definition template <typenameT> classFormatter { T* m_t; public: Formatter(T* t) : m_t(t) { } void print() { cout << *m_t << endl; } }; int main() { inti = 157; // Use the generic template with int as the argument. Formatter<int> formatter1(&i); charstr[10] = "string1"; char* str1 = str; // Use the specialized template. Formatter<char*> formatter2(&str1); formatter1.print(); // 157 formatter2.print(); // Char value : s } // Specialization of template class // for type char* template<> classFormatter<char*> { char** m_t; public: Formatter(char** t) : m_t(t) { } void print() { cout << "Char: " << **m_t << endl; } }; Joey Paquet, 2007-2018

13. Pitfall: C++ templates and static data members and local variables • As they are translated to separate classes, each template class instance has its own copies of any static variables or members. • Here, X<int>has its own static member int s, which is shared by all instances of the type X<int>. • X<char*>has its own static member char* s, which is shared by all instances of the type X<char*>. • 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: int main() { X<int> xi ; cout << "xi.s = " << xi.s << endl ; X<char*> xc ; cout << "xc.s = " << xc.s << endl ; return 0 ; } template <classT> classX { public: staticT s ; }; int main() { X<int> xi ; X<char*> xc ; } template <> intX<int>::s = 3 ; template <> char* X<char*>::s = "Hello" ; template <classT> void f(Tt) { staticT s = 0; s = t ; cout << "s = " << s << endl ; } int main() { f(10) ; f("Hello") ; return 0 ; } Joey Paquet, 2007-2018

14. Pitfall: Templates and separate compilation • 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<float> and Stack<int>. 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<T>.push() and Stack<T>.pop(). As the declaration of these templates are in Stack.cpp (a different compilation unit), compilation fails. Joey Paquet, 2007-2018

15. Pitfall: Templates and separate compilation // Stack.h // template class declaration template <typenameT> classStack { public: Stack(int = 10); ~Stack() { delete[] stackPtr; } int push(constT&); int pop(T&); intisEmpty()const { return top == -1; } intisFull() const { return top == size - 1; } private: int size; int top; T* stackPtr; }; Stack.cpp //template class method definitions #include"Stack.h" template <typenameT> Stack<T>::Stack(ints) { size = s > 0 && s < 1000 ? s : 10; top = -1; // initialize stack stackPtr = newT[size]; } // push an element onto the Stack template <typenameT> intStack<T>::push(constT& item) { if (!isFull()) { stackPtr[++top] = item; return 1; // push successful } return 0; // push unsuccessful } // pop an element off the Stack template <typenameT> intStack<T>::pop(T& popValue) { if (!isEmpty()) { popValue = stackPtr[top--]; return 1; // pop successful } return 0; // pop unsuccessful } // StackDriver.cpp #include"Stack.h" void main() { Stack<float> fs(5); float f = 1.1; while (fs.push(f)) { cout << f << ' '; f += 1.1; } while (fs.pop(f)) cout << f << ' '; Stack<int> is; inti = 1.1; while (is.push(i)) { cout << i << ' '; i += 1; } while (is.pop(i)) cout << i << ' '; } Joey Paquet, 2007-2018

16. Pitfall: Templates and separate compilation • 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. templateclassStack<int>; templateclassStack<float>; Joey Paquet, 2007-2018

17. C++ templates vs. Java generics • 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. Joey Paquet, 2006-2014

18. C++ templates vs. Java generics • 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. /** * Generic class that defines a wrapper class around a single * element of a generic type. */ publicclass Box<T extends Number> { privateTt; publicvoid set(Tt) { this.t = t; } publicT get() { returnt; } publicvoid 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<U> void inspectWithAdditionalType(Uu){ System.out.println("T: " + t.getClass().getName()); System.out.println("U: " + u.getClass().getName()); } publicstaticvoid main(String[] args) { Box<Integer> integerBox = new Box<Integer>(); integerBox.set(new Integer(10)); integerBox.inspect(); integerBox.inspectWithAdditionalType("Hello world"); Integer i = integerBox.get(); } } Joey Paquet, 2006-2014

19. C++ templates vs. Java generics • In Java, when 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. /** * Generic class that defines a wrapper class around a single * element of a generic type. */ publicclass Box{ privateNumbert; publicvoid set(Numbert) { this.t = t; } publicNumber get() { returnt; } publicvoid 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. */ publicvoid inspectWithAdditionalType(Objectu){ System.out.println("T: " + t.getClass().getName()); System.out.println("U: " + u.getClass().getName()); } publicstaticvoid main(String[] args) { Box integerBox = new Box(); integerBox.set(new Integer(10)); integerBox.inspect(); integerBox.inspectWithAdditionalType("Hello world"); Integer i = integerBox.get(); } } Joey Paquet, 2006-2014

20. C++ templates: facts • 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 unnecessary 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. • As the template instances are generated code that is later being compiled, error reporting tends to be cryptic and seemingly unrelated to the source code. • C++ templates are fundamentally a different concept than Java/C# generic classes. Joey Paquet, 2007-2018

21. References • Bjarne Stroustrup. The C++ Programming Language. Chapter 23. Fourth Edition, Addison Wesley. • Daniel Liang. Introduction to Programming with C++. Chapter 12. Third Edition, Pearson Education. • http://users.cis.fiu.edu/~weiss/Deltoid/vcstl/templates • http://stackoverflow.com/questions/495021/why-can-templates-only-be-implemented-in-the-header-file Joey Paquet, 2007-2018