of Uses Templates
1. Homogeneous container classes 2. The algorithms that use them 3. Function objects 4. Mixins
1. Container Classes
Class whose instances can hold objects of other classes
Sets, lists, maps, stacks, queues, etc. Homogeneous container classes require all held objects to be of the same class (the element type) or its subclasses
Java 1.4 solution
All contained elements of class Object Downcast on retrieval Lack of data polymorphism
C++ solution: template classes
Standard Template Library (STL)
STL Containers
Homogeneous, templatized container classes deque, list, map, set, multimap, multiset, queue, stack, vector Iterators support traversals without revealing implementation
STL Example - vector<>
Constructors
#include <vector> vector<int> vec0; vector<int> vec1(10); vector<int> vec2(10, -6); int ia[4] = {0, 1, 2, 3}; vector<int> vec3(ia, ia + 4); vector<int> vec4(vec2);
STL Example - 2
Traversal (overloaded [])
int size = 5; vector<int> vec(size); for (int ix = 0; ix < size; ++ix) vec[ix] = ix;
Traversal (iterator)
vector<int>::iterator iter = vec.begin(); for (int ix = 0; iter != vec.end(); ++iter, ++ix) *iter = ix;
Iterators
Mechanism for delivering elements of a collection without revealing the collections implementation Categories
Input (getters) Output (setters) Forward (read/write) Bidirectional Random access
Iterator Details
begin() and end() ++iter gives next; *iter gives value (or lvalue) Support for scalar arithmetic (iter += 5) const and non-const versions reverse insert (front, back, inserter)
Vector Iterator Example
#include < vector > extern int getSize(); void mumble() { int size = getSize(); vector< int > vec( size ); vector < int >::iterator iter = vec.begin(); for ( int ix = 0; iter != vec.end(); ++iter, ++ix ) *iter = ix; }
Example - 2
int ia[10] = {51, 23, 7, 88, 41, 98, 12, 103, 37, 6}; vector<int> vec(ia, ia + 10); int search_value; cin >> search_value; vector<int>::iterator found; found = find(vec.begin(), vec.end(), search_value); if (found != vec.end()) cout << "search_value found!\n"; else cout << "search_value not found!\n";
2. Generic Algorithms in STL
First two arguments are a pair of iterators
Beginning and end of container
Alternate versions
Built in operator Function object Pointer to function
Alternative versions for container modification
In-place In-copy
#include <algorithm> <numeric>
Adjacent difference, accumulate, inner product, partial sum
3. Function Objects
Classes can define methods that override builtin operations
E.g. use + to add two rationals together
One such operator is (), the method call operator If a class named f overrides (), then fi(x, y) invokes the overriding method and passes it two arguments, where fi is an instance of class f
The object is nothing more than a shell around a method Because it is an object, it can be passed around and composed
The Standard Template Library (STL) makes heavy use of function objects
Uses of Function Objects
Passed as parameter to template function Can be inlined Can store state Can be composed (functional programming)
Motivating Example
Functions can use other functions (minval uses a comparison function)
template <typename T> const T& min(const T *p, int size) { T minval = p[0]; for (int ix = 1; ix < size; ++ix) if (p[ix] < minval) minval = p[ix]; return(minval); }
Wouldn't work for strings! Need an alternative mechanism
Possible Solutions
Function pointers
Cant be inlined Adds a level of indirection
Macros
Multiple side effects:
#define twice(x) (x*x)
Name scopes are lexical rather than syntactic
Function objects
Pointer to Function Example
template <typename T, bool (*Comp)(const T&, const T&)> const T& min(const T *p, int size, Comp comp) { T minval = p[0]; for (int ix = 1; ix < size; ++ix) if (Comp(p[ix], minval)) // Function not method minval = p[ix]; return(minval); }
Function Object Example
class IntComparator { // Function object for ints public: bool operator() (int val1, int val2) { return(val1 < val2);} }; template <typename T, typename C> const T& min(const T *p, int size, C cmp) { T minval = p[0]; for (int ix = 1; ix < size; ix++) if (cmp(p[ix], minval)) minval = p[ix]; return(minval); }; IntComparator icf; min(arr, 10, icf);
Sources of Function Objects
Standard Template Library (STL)
Predefined arithmetic, relational, logical (#include <functional>) Binders: converts a binary function to unary by fixing one of its arguments; partial evaluation Adapters (negators); reverses sense of a boolean function
User defined
Example
Function object specialized to a single value (10) class less_equal_ten { public: bool operator() (int val) {return(val <= 10);} }; count_if (vec.begin(), vec.end(), less_equal_ten()); // count_if is a generic algorithm from the STL count_if (vec.begin(), vec.end(), not1(less_equal_ten())); // not1 is an adapter that takes one argument of type // (function of one argument returning bool)
Alternative Approach
Generalize by using constructor to supply value class less_equal_value { public: less_equal_value(int val) : _val(val) {} bool operator() (int val) {return(val <= _val);} private: int _val; }; count_if(vec.begin(), vec.end(), less_equal_value(10));
Another Alternative
Templatized function object with value supplied in template parameter template <int _val> class less_equal_value { public: bool operator() (int val) {return(val <= _val);} }; count_if(vec.begin(), vec.end(), less_equal_value<10>()); // But _val must be a constant
4. Mixins
Class fragment intended to be composed with other classes Two implementations
Secondary superclasses when multiple inheritance is used class Foo : public Bar, public Mix {}; Parameterized class with superclass taken from parameter (abstract subclass) template <typename Mix> class Foo : public Bar, public Mix {};
Motivating Class Exampe
Client needs to invoke the services of another class Server With traditional C++ dynamic method-binding, Client invokes services by calling them indirectly through a pointer to a particular Server object
Traditional Solution
class Server { public: void service() { ... } }; class Client { public: void function(Server& s) { ... s.service(); ... } }; // main Client cl; Server se; cl.function(se);
Multiple Inheritance Solution
class ServiceInterface { // Grandparent public: virtual service() = 0; // pure virtual } class Server : public virtual ServiceInterface { public: service() {...} // Parent 1 } class Client : private virtual ServiceInterface { public: function() { ... service(); ... } // Parent 2 } class System : public Client, private Server {} // Child
Explanation
ServiceInterface is an abstract class that defines a pure virtual operation service. It holds the top position in the diamond Class Server is a concrete class that inherits from ServiceInterface and provides the implementation method for the service operation. It is one of the two parents in the diamond Class Client is a concrete class that define an operation function, implemented by invoking service(). It is the other parents Operations in Client can invoke operations declared in ServiceInterface by name, as Client inherits the signatures for all of these operations from ServiceInterface Because Client uses private inheritance, operations in ServiceInterface do not become part of the Client interface Class System combines Client and Server, binding the uses of the service operation in Client to the method that implements it, which is defined in Server. It is the bottom of the diamond
Parameterized Inheritance Solution
By implementing Client with parameterized inheritance and instantiating it with Server, we get an efficient implementation that avoids the indirection
Template Solution
class Server { public: void service() { ... } }; template<class SERVER> class Client : SERVER { public: void function() { ...SERVER::service();... } }; // main Client<Server> cl; cl.function();
Explanation
Client is a mixin class whose parameter can be any class providing the required service, in this case Server When Client is instantiated with Server as its template parameter, an actual class sys is defined Note that Server becomes a parent class to Client. That is, service is an actual method in Client, meaning that no object pointer is required. Invocation of sys.function causes method service in class Server to be called without paying the cost of an indirect reference typical of dynamic (or even static) binding
Template Mixin Advantages
Compared to multiple virtual inheritance, templatized mixins have the following advantages
May require fewer classes
No need for a child class to inherit the base and the mixin No need for artificial grandparent class
One less level of indirection Can be written from a bottom-up point of view
Compared to traditional dynamic binding, there is no costly indirection, nor any distracting pointer
Case Study
Comparison between parametric and subtype polymorphism
General mechanism for swapping two variables Variables must be of the same type
Process
Determine required operations Define abstract type with those operations as virtual functions Rewrite swap routine using abstract type as types of parameters
Parametric Solution
template <class T> void swap (T& a, T& b) { const T c = a; a = b; b = c; }
Subtyping Solution
Must define an abstract class that characterizes swappability Have the class of the variables to be swapped inherit from the abs...