Overview of C++ Templates Templates are used to parameterize classes and functions with different types Function templates do not require explicit declaration of the parameterized types when called Classes require explicit declaration of parameterized types when instantiated Some compilers require that template definitions be included with declarations – others do not

Function Templates template <typename T> void swap(T & lhs, T & rhs) { T temp = lhs; lhs = rhs; rhs = temp; } int main () { int i = 3; int j = 7; swap (i, j); // i is now 7, j is now 3 return 0; Function template swap takes a single type parameter, T interchanges values of two passed arguments of the parameterized type Compiler instantiates the function template with type int in main Note that the compiler infers that the type is int when swap is called Based on the types of the arguments i and j

Function Template Example STL linear search (based on Austern pp. 13): template <typename Iterator, typename T> Iterator find2 (Iterator first, Iterator last, const T & value) { while (first != last && *first != value) { ++first; } return first; Our first generic algorithm Searches any one-dimensional sequence of elements “Not found” is a normal result, does not throw exception Returns position last: just past the end of the range [first, last)

More about Concepts and Models A concept defines type requirements A predicate to classify/categorize types Any specific type that meets the requirements is a model of that concept What requirement(s) does the expression return first; impose? What about while(first != last && *first != value) { ++first; } Iterator const T &

Interface Polymorphism: Refinement A concept C is a refinement of concept D if C imposes all of the requirements of D Modeling and refinement satisfy three formal properties Reflexivity: A concept refines itself Containment: if T models C and C refines D then T models D Transitivity: If C refines D then C refines any concept D refines What in the OO paradigm is this like? How does it differ? C0 transitivity C1 T1 T2 C2 containment T3 T4 can substitute, e.g., T3 for T1

Class Templates Start with a simple declaration template <typename T> class Array { public: Array(const int size); ~Array(); const int size () const; private: T * m_values; const int m_size; }; int main (int, char**) { Array <int> a(10); return 0; } Start with a simple declaration Which we’ll expand as we go Notice that parameterized type T is used within the class template Type of pointer to array When an instance is declared, must also explicitly specify the concrete type parameter E.g., int in function main (int, char**)

Class Templates and Inheritance class ArrayBase { public: ArrayBase(const int size); ~ArrayBase(); const int size () const; protected: const int m_size; }; template <typename T> class Array : public ArrayBase { Array(const int size); ~Array(); private: T * m_values; Class templates can inherit from base classes Or class templates, but must relate type parameters to those of base Here, we’ve separated template and non-template code Non-template base class Template derived class Functions and variables that do not need to refer to type parameters go into the base class This is useful in many cases To avoid accidental type errors (ArrayBase doesn’t access T) To reduce program size (separate method definitions compiled for Array<int> Array<float> etc.)

One Last Detail: Associated Types template <typename T> class Array : public ArrayBase { public: typedef T* iterator; Array(const int size); ~Array(); iterator begin () { return m_values;} iterator end () { return m_values+m_size;} private: T * m_values; }; void foo { Array<int> a; fill_array(a); for (Array<int>::iterator i = a.begin(); i != a.end(); ++i) { cout << *i << “ ” << endl; } The exact type of a type parameter is not known The compiler can work around that in many cases But sometimes it needs more information Additional information can be associated with a type For example, a class template can define an iterator type Available to the template and code that uses the template More about how this is done (and why) in later lectures

Tips on Templates The set of requirements that a class template or function template places on its parameterized types is called a concept in generic programming terminology Any type that meets those requirements is said to model the concept, and can be used in that template Concept refinement supports interface polymorphism Push common code and variables up into non-template base classes Can help avoid subtle type errors Can help reduce the size of the executable program Associated types expand the power of templates E.g., used extensively in the C++ Standard Template Library

For Next Time Topic No assigned readings Template Examples Please catch up if you’ve not done so already