Generic Code

• Alternative to "run-time polymorphism"
• With virtual functions, subclasses provide implementations to base class interfaces
• Such implementations are selected at run-time
• In template code, parameter types are expected to have certain properties in common
• These properties specify a compile-time interface
• Different type arguments can implement this interface in different ways
• When real types bind to template parameters, we have "compile-time-polymorphism"

Example (from the C++ Standard Template Library)

template < class T > class vector { // vector implementation ... };

• Dynamically expanding/shrinking array class
• Arguments for type parameter T have 2 requirements:
       - must be copy constructible
       - must be assignable

vector<int> a(7, 3);        // creates vector of 7 ints, initialized to 3
vector<float> b(7, 1.0);  // creates vector of 7 floats, initialized to 1.0

• Third requirement for certain situations:
       - must be default constructible

vector<int> a(10);        // creates vector of 10 ints, default initialized (to 0)
vector<float> b(10);     // creates vector of 10 floats, default initialized (to 0.0)

• These requirements form a compile-time interface
• Some requirements only needed for certain method calls
• If these are satisfied, generic vector methods can do everything they need to do
• Can use any class type that conforms to this interface

class complex
{
      double real_part;
      double imaginary_part;
public:
      complex();                                               // default constructor
      complex(double real, double imaginary);   // sets real and imaginary parts
      complex(const complex &);                     // copy constructor
      complex &operator=(const complex &);  // assignment operator
      // other methods ...
};

vector<complex> a(10, complex(1.0, 2.0));
// creates a vector of 10 complex values, initialized to 1 + 2i
vector <complex> b;            
b = a;                           // vector assignment uses complex :: operator=

Consider alternative with run-time polymorphism:

class Object   // abstract base instead of generic template type
{
public:
     virtual Object *clone() = 0;                     // equivalent to copy constructor
     virtual void assign(const Object &) = 0;  // like assignment operator
     // other methods
};

class Vector  // stores pointers to Objects
{
// will call init_val.clone() to create copies
     Vector(int num_elements, const Object &init_val);
// will invoke clone() on elements of rhs to create copies of elements
     Vector(const Vector &rhs);
// will invoke assign() on elements of (*this) to copy element values from rhs
     Vector &operator=(const Vector &rhs);
};

class Integer: public Object   // sample Object implementation
{
      int value;
public:
      Integer(): value(0) {}
      Integer(const Integer &rhs): value(rhs.value) {}
      Integer *clone() { return new Integer(*this); } // implements Object::clone()
      void assign(const Object &o)                         // implements Object::assign()
      {
            Integer *i = dynamic_cast<Integer *>(&o); // does run time check
            if (i != 0)                                                     // null returned if not an Integer
                assign(*i);                                               // calls Integer-specific assign
            else
                // throw some exception
      }
     void assign(const Integer &i) { value = i.value; } // Integer-specific assign
};

Vector a(10, Integer(3)); // creates a vector of 10 Integers with value 3

Compare to generic vector<> template:

• Less flexible: elements in container must derive from Object
• All methods from Object must be implemented, whether needed or not
• Less efficient: more indirection from use of pointers, run-time checks often needed
• Less type safe: no guarantee elements are of same type without run-time checks
• With generics, all type checking is done at compile time

C++ Standard Template Library

• A wealth of generic code applicable to a wide variety of types and situations
• Classes, functions, perform many common tasks typically rewritten time and time again  in C programs
• C++ programmers don't have to "reinvent the wheel" with each new type they create

STL Containers

• Generic templates that implement common data container types
• All can be instantiated for any element type that satisfies the above requirements
• Simple containers:
       - vector  --  dynamically expanding/contracting array
       - list  --  doubly linked list
       - deque  -- double-ended queue; like vector, but can insert at front in constant time
       - queue  -- regular queue; push at one end, pop at other
       - stack  -- simple stack; push and pop at same end
       - priority_queue  --  an "ordered" queue (heap); pops highest-priority element
• All containers have an iterator type meant to resemble a pointer

#include <vector>  // vector class header
#include <list>       // list class header
using namespace std;

vector < int > v(10);     // fills v with 10 default ints (0)
list < float > l(10);        // fills l with 10 default floats (0.0)
vector < int > :: iterator v_iter = v.begin();  // points to first element of v
list < float > :: iterator l_iter = l.end();      // points to one-past-end of  l

• Each iterator type is a distinct type, but all conform to certain requirements
• Some iterators are often implemented as regular pointers (like vector :: iterator)
• Some need to be more complicated (like list :: iterator)
• Each one can be incremented (++), decremented (--) and dereferenced (*)
• Can also be compared for equality or inequality to other elements (operators = =, !=)
• Some are random access, implement operators [], < (e.g. vector, deque, but not list)
• Can exploit this common interface with generic template code

Example:

template < class T, class iterator_type >
    void fill_range ( iterator_type begin, iterator_type end, T value)
    {
            while (begin != end)
                 *begin++ = value;
    }

• Can use any type that implements operators ++, *, and !=
• This includes regular pointers, as well as STL container iterators
• Don't need the [] or < operator for this one, so list :: iterator is OK
• *iter doesn't need to be of type T, just some type a T can convert to

fill_range(v.begin(), v.end(), 7)         // fills vector v with value 7
fill_range(l.begin(), l.end(), 6.8)        // fills list l with value 6.8
complex a[20];
fill_range(a, a + 20, complex(3, 7)) // fills array of complex with value 3 + 7i

• Each iterator type instantiates a different version of fill_range
• Compiler deduces types T and iterator_type from arguments provided

Run-time polymorphism version of iterators would look like:

class Iterator
{
     virtual void increment() = 0;                    // like operator++
     virtual void decrement() = 0;                   // like operator--
     virtual Object &current_element() = 0;    // like operator*
};

• Subclasses like Vector_Iterator and List_Iterator would implement these methods
• Same problems as Vector class above

STL Algorithms

• Header < algorithm > provides a number of useful algorithms
• Similar to the one above, all are templates that work with generic iterator types
• Use 2 to specify a range: beginning and one-past-the-end
• Some are simple (but convenient) like copy:

#include <algorithm>
using namespace std;

complex b[15];
copy(a, a + 15, b);  // specify beginning and end of source, beginning of destination
                               //  copies first 15 elements of a to b

• Some perform more nontrivial tasks, with more requirements, like sort

sort(v.begin(), v.end())  // sorts elements of vector v
                                    // requires that element type implements operator <