Templates Consider the following function, which swaps two integers: void swap(int &x, int &y) { int temp = x; x = y; y = temp; } int i = 3, j = 4; swap(i, j);

void swap(int &x, int &y) { int temp = x; x = y; y = temp; } Now suppose we also want a function to swap floats. Then we write another function (we can overload the name “ swap ” for different argument types): void swap(float &x, float &y) { float temp = x; x = y; y = temp; } float f = 4.0, g = 5.0; swap(f, g);

But writing the same code over and over for every possible type can get tiring fast. What we’d really like would be a single swap function that worked for all types. Let’s express what we want as follows: // For any type T, swap two elements of type T: void swap(T &x, T &y) { T temp = x; x = y; y = temp; } swap is supposed to take an two elements of some type (let’s call this type T for the moment), and swap them. But we don’t know what T is when we write swap - ideally, swap should work for all possible types T.

C++ supports template declarations which express exactly what we want: template void swap(T &x, T &y) { T temp = x; x = y; y = temp; } This declares a template function swap which can swap any type. A template is sort of like a function that takes a type as a parameter. The “ class T ” declaration indicates that T is an argument which can be instantiated with any type (despite the name “ class ”, this type can be any type, not just a class type).

template void swap(T &x, T &y) { T temp = x; x = y; y = temp; } swap can be instantiated with different types to produce swap functions specialized to particular types: swap is a function that swaps int s. swap is a function that swaps string s. For example, swap substitutes int for T to produce a function to swap int s: void swap(int &x, int &y) { int temp = x; x = y; y = temp; }

template void swap(T &x, T &y) { T temp = x; x = y; y = temp; } Here’s an example that uses swap to swap a couple of integers, and swap to swap a couple of floating point numbers: int i = 3, j = 4; swap (i, j); float f = 4.0, g = 5.0; swap (f, g);

template void swap(T &x, T &y) { T temp = x; x = y; y = temp; } In practice, C++ can usually infer the right type parameter based on the arguments to a template function: int i = 3, j = 4; swap(i, j); // uses swap float f = 4.0, g = 5.0; swap(f, g); // uses swap

To see how useful templates can be, recall the qsort function in stdlib.h : void qsort(void *base, int num, size_t width, int (*compare)(void *elem1, void *elem2 ) ); This was messy to use because of void*. For instance, our compare function for integers looked like: int compareInt(void *i1Ptr, void *i2Ptr) { if(*((int*)i1Ptr) < *((int*)i2Ptr)) return -1; else if(*((int*)i1Ptr) == *((int*)i2Ptr)) return 0; else return 1; }

We can use templates to get rid of the void*: template void qsort(T *base, int num, int (*compare)(T& elem1, T& elem2 ) ); This declares a template function qsort which can sort any type.

template void qsort(T *base, int num, int (*compare)(T& elem1, T& elem2 ) ); Example (notice that we can write a nice compareInt function without a bunch of casts): int compareInt(int& i1, int& i2) { if(i1 < i2) return -1; else if(i1 == i2) return 0; else return 1; } int iArr[4]; iArr[0] = 3; iArr[1] = 2; iArr[2] = 7; iArr[3] = 5; qsort (iArr, 4, compareInt);

Notice also that the templates enforce a stronger typing property than the void* did: the type of the compare function passed in must match the type of the array. So qsort(iArr, 4, compareInt); typechecks, because compareInt and iArr both are built out of type int. But string sArr[4]; qsort(sArr, 4, compareInt); won’t typecheck, because sArr doesn’t match the type of the compareInt function.

Templates can also be used to create generic data structures. Consider our old FloatArray class, which only worked for elements of type float : class FloatArray { float *arr; int arrSize; public: FloatArray(int size); FloatArray(const FloatArray& from); FloatArray& operator = (const FloatArray& from); ~FloatArray(); float get(int i) const; void set(int i, float f); int size(); };

By declaring and implementing the class as a template, we can make it work for any type: template class TArray { T *arr; int arrSize; public: TArray(int size); TArray(const TArray & from); TArray & operator = (const TArray & from); ~TArray(); T get(int i) const; void set(int i, T f); int size(); }; For example, TArray is a class for an array of float s, and TArray is a class for an array of string s.

template class TArray { T *arr; int arrSize; public: TArray(int size); TArray(const TArray & from); TArray & operator = (const TArray & from); ~TArray(); T get(int i) const; void set(int i, T f); int size(); }; Example: TArray tArr(4); tArr.set(3, 5); int i = tArr.get(3);

template class TArray { T *arr; int arrSize; public: TArray(int size); TArray(const TArray & from); TArray & operator = (const TArray & from); ~TArray(); T get(int i) const; void set(int i, T f); int size(); }; Implementing member functions of a template class: template int TArray ::size() { return arrSize; }

Template functions and template classes can be used together. For instance, the following function sorts a TArray : template void arraysort(TArray &arr, int (*compare)(T& elem1, T& elem2 ) ); Notice again that the element type of the TArray must match the type used by the compare function. Example: TArray tArr(4);... arraysort (tArr, compareInt);

A template can take multiple type arguments: template class Pair { public: T x1; U x2; Pair(T a1, U a2): x1(a1), x2(a2) {} }; Pair p1("deep ", 6); cout << p1.x1 << p1.x2 << endl;

The standard template library There are a number of built-in data structures that are available for you to use, such as list and vector. For instance, list is a list of string s, and vector is a vector of pointers to Shape s. Example: #include using namespace std; // necessary on some platforms list l1; // list of ints vector v1; // vector of pointers to Shapes

2 dimensional arrays can now be implemented as vectors of vectors: vector > arr; Pitfall: the space in “ > > ” is necessary. If you type: vector > arr; then C++ thinks the >> means “right-shift”.

Polymorphism strikes again Remember how inheritance and virtual functions led to a form of polymorphism? A variable of type Shape could hold many different types of objects at run-time ( Circle s, Triangle s, etc.). Templates also provide a form of polymorphism. Inside a template function or class, a variable of type T may refer to many different types of objects, depending on what type T is instantiated with.

Let’s see how these two forms of polymorphism compare. Before templates were introduced into C++, many vendors provided data structure classes based on inheritance. Usually, all elements would have to be derived from a common base class called Object. Then the data structure classes would work with Objects: class Array { Object **arr; public:... Object* get(int i) const; void set(int i, Object* f); };

class Array { Object **arr; public:... Object* get(int i) const; void set(int i, Object* f); }; So if we write a class that inherits from Object, we can put objects of this class into an Array : class MyString: public Object {... }; Array arr(5); arr.set(0, new MyString(“hello”)); arr.set(1, new MyString(“there”));

class Array { Object **arr; public:... Object* get(int i) const; void set(int i, Object* f); }; But if we try to read a MyString object from the array, we find it has type Object* instead of MyString *: Object *o = arr.get(0); So we have to do a cast (yuck!) to make it a MyString* : MyString *m = (MyString *) o;

With templates, we know that the type we get out of a data structure is exactly the type we put into the data structure. So no cast is necessary: template class TArray { T **arr; public:... T* get(int i) const; void set(int i, T* f); }; Array arr(5); arr.set(0, new MyString(“hello”)); arr.set(1, new MyString(“there”)); MyString *m = arr.get(0); // no cast necessary So templates are clearly a nicer, safer way to implement generic data structure classes.

On the other hand, inheritance is the best way to express a common interface shared by a collection of closely related classes. For instance, a collection of shapes can rely on a common base class Shape : class Shape {... public: virtual void draw(); virtual void rotate(double angle); virtual double area(); }; class Circle: public Shape {...}; class Triangle: public Shape {...};

Suppose we didn’t use inheritance to implement shapes, and instead defined each shape independently, without a common base class: class XCircle {... void draw(); void rotate(double angle); double area(); }; class XTriangle {... void draw(); void rotate(double angle); double area(); };

Now suppose we wrote a template function rotateAndDraw, designed to work for XCircle s and XTriangle s: template void rotateAndDraw(T &s, double angle) { s.rotate(angle); s.draw(); } The function assumes that T contains rotate and draw member functions, but it doesn’t document this clearly. For instance, it doesn’t say what argument and return types the rotate and draw functions should have. This is bad style.

It isn’t clear from the template declaration template void rotateAndDraw(T &s, double angle); what types are valid for T. For instance, is an int ok? rotateAndDraw (5, 3.0); // ??? This in fact does not typecheck, because int s don’t have rotate and draw functions. However, we have to look at rotateAndDraw ’s implementation to figure this out. Using inheritance is much better in this case: void rotateAndDraw(Shape &s, double angle) { s.rotate(angle); s.draw(); } Here, the type of s is clearly stated.

Inheritance also allows more heterogeneity. Suppose we want a single list that holds all different kinds of shapes. If shapes aren’t related by inheritance, we can create lists of specific types: list l1; list l2; But l1 can only hold XCircle s, and l2 can only hold XTriangle s. Neither list can hold a mixture of the two. If Circle and Triangle share the base class Shape, though, then list l3; can hold all different kinds of shapes, including Circle s and Triangle s.

Notice that list l3; takes advantage both of templates and inheritance. This combination of templates and inheritance is quite common and very useful. It uses the strengths of templates and inheritance in a complementary way.

Templates: the good, the bad, the ugly good: templates are excellent at expressing generic algorithms and data structures bad and ugly: template implementations go into header files instead of.cpp files template instantiations create multiple copies of a template’s code template uses can’t be typechecked without expanding the entire template

Problem #1: On most platforms, the entire implementation of a template must go in the header file: // swap.h: template void swap(T &x, T &y) { T temp = x; x = y; y = temp; } //.cpp file: #include “swap.h”... This violates everything we’ve told you about source code organization. Usually only declarations go in the header file, and implementations go in a.cpp file.

Problem #2: A different copy of a template’s code is produced for every different type passed in as the templates type parameter. template void qsort(T *base, int num, int (*compare)(T& elem1, T& elem2 ) ); For instance, if the qsort template above is instantiated for int s, float s, and string s, then 3 different copies of qsort ’s code are generated: qsort (...); // generates code for qsort

If the templates are complicated, then this “code bloat” can get quickly out of hand. C++ programmers sometimes complain that their executable files are many megabytes in size because of template instantiation. By contrast, the old qsort in stdlib.h only required one copy of the code, which worked for all types (through the admittedly clunky void* mechanism).

Problem #3: typechecking template instantiations template void rotateAndDraw(T &s, double angle); We’ve already seen the rotateAndDraw example that expects its type T to have rotate and draw member functions. This means that trying to use rotateAndDraw (5, 3.0); won’t typecheck. But how do we know that it won’t typecheck? We have to look through rotateAndDraw ’s implementation, to see what things it does with the objects of type T. This violates the idea of separating the implementation of a function from its interface.

A practical consequence of this is that C++ needs to expand out uses of a template entirely before it can typecheck them. If the template is complicated, This leads to remarkably obscure type errors when something goes wrong. Here’s a small (incorrect) example that uses the standard library class map : map m1; // maps strings to ints // incorrectly tries to insert a pair (“hello”, 6) // into the map: m1.insert(m1.begin(), make_pair("hello", 6)); This incorrectly passes in a char* argument ( “hello” ) to make_pair instead of a string. Let’s see what type error we get.

map m1; // maps strings to ints m1.insert(m1.begin(), make_pair("hello", 6)); Visual Studio 5.0 reports the following type error: error C2664: 'class std::_Tree,class std::allocator >,struct std::pair, class std::allocator >,int>,struct std::map,class std::allocator >,int,struct std::less,class std::allocator >>,class std::allocator >::_Kfn,struct std::less,class std::allocator >>,class std::allocator >::iterator std::map,class std::allocator >,int,struct std::less,class std::allocator >>,class std::allocator >::insert(class std::_Tree,class std::allocator >,struct std::pair,class std::allocator >,int>,struct std::map,class std::allocator >,int,struct std::less,class std::allocator >>,class std::allocator >::_Kfn,struct std::less,class std::allocator >>,class std::allocator >::iterator,const struct std::pair,class std::allocator >,int> &)' : cannot convert parameter 2 from 'struct std::pair ' to 'const struct std::pair,class std::allocator >,int> &'

Don’t be scared off too much by the problems with C++ templates. Templates are still a good idea! But we need to remember that templates are best used for small, simple container classes. Large and complicated templates (such as the map example above) often lead to code bloat and difficult error messages. Simple classes, like list and vector, tend to work very well in practice. We’ll explore these standard library classes in the next lecture.