Generic Programming and STL

Outline

• Generic Programming & STL
  • SGI' Standard Template Library Programmer's Guide
  • STLPort - a port of the STL library that can be downloaded at no charge.
• CGAL - upper convex hull
• Demos

Dictionary

STL

The C++ Standard Template Library

CGAL

The Computational Geometry Algorithm Library

Generic Programming

A programming paradigm with concepts (massivly uses templates)

Class Template

Specialization

Template Parameter

Concept

A set of requirements that a class must fulfill

Model

A concrete class that fulfills the requirements of a concept

Traits

Refinement

Generic Algorithms

Containers

Iterators

Generalization of pointers; objects that point to other objects.

Function Objects (Functors)

Adaptors

Allocators

Generic algorithms

• A generic algorithm has 2 parts:
  • The actual instructions that describe the steps of the algorithm
  • A set of requirements that specify which properties its argument types must satisfy.

A basic example: swap()

• When the function is called, it is instantiated with a data type.
• This data type must have an assignment operator.
• This defines the concept of our algorithm.
• In this example, the int data type is a model of our concept commonly called assignable.

template <class T> void swap(T& a, T& b)
{
  T tmp = a; a = b; b = tmp;
}

A Simple Example: Version 1 - Standard C++

• A program that reads integers, sorts them, and prints them out

#include <stdlib.h>
#include <iostream>

inline int cmp(const void * a, const void * b)
{
  int aa = *(int *)a;
  int bb = *(int *)b;
  return (aa < bb) ? -1 : (aa > bb) ? 1 : 0;
}
 
int main(int argc, char * argv[])
{
  const int size = 1000;
  int array[size];
  int n = 0;
  while (std::cin >> array[n++]);
  n--;          // it got incremented once too many times
  qsort(array, n, sizeof(int), cmp);
  for (int i = 0; i < n; ++i)
    std::cout << array[i] << std::endl;
  return 0;
}

STL Containers

• STL provides a number of container types
• They represent objects that contain other objects
  • list - a doubly linked list.
  • set - no 2 elements are the same. Implemented using something like a Red-Black tree. Requires a functor that compares 2 values for ordering.
  • map - associates objects of one type (Key) with objects of another type (Data).
  • more...

A Simple Example: Version 2 - Containers, Iterators, Algorithms

• Using STL vector container.

#include <stdlib.h>
#include <string>
#include <algorithm>
#include <vector>
#include <iostream>
 
int main(int argc, char * argv[])
{
  std::vector<int> v;           // create an empty vector of integers}
  int input;
  while (std::cin >> input)     // while not end of file}
    v.push_back(input);         // append to vector}
  std::sort(v.begin(), v.end());
  int n = v.size();
  for (int i = 0; i < n; ++i)
    std::cout << v[i] << std::endl;
  return 0;
}

The vector container

• Behaves like an array
• Can grow itself as necessary
• Supports push_back()
  • Pushes an element onto the end of the vector (growing it by one).
• Contains a block of contiguous initialized elements
  • If element index k has been initialized, then so have all the ones with indices less than k.
• Can be presized - supplying the size at construction
• Can be asked how many elements it has with size().
• Can be asked for its capacity -- the number of elements the vector can hold before reallocating.

Iterators

• Provide a way of specifying a position in a container.
• Can be incremented or dereferenced.
  with the '++' and '*' operators.
  • Some can be decremented with the '--' operator.
  • Some can be indexed with the '[]' operator.
• Two iterators can be compared.
• There is a special iterator value called "past-the-end".
• c.begin() and c.end() return the first and "past-the-end" iterators of the container c

vector<int> v;
vector::iterator i1 = v.begin();
vector::iterator i2 = v.end();
while (i1 != i2) {
  ...
  ++i1; 
}

Iterator Types and Refinement

• There are several different ways of generalizing pointers.
• Each is a distinc concept.
  1. Input Iterator
  2. Output Iterator
  3. Forward Iterator
  4. Bidirectional Iterator
  5. Random Access Iterator

The sort() algorithm

• The sort() routine is generic
  • It works on many different types of containers.
  • It deals with Iterators instead of the containers themselves
• Takes two iterators to specify the semi-open range source
  • Sort is an overloaded name. Another version takes a functor that compares 2 values for ordering.
• Incidentally, this is much faster than qsort; presumably due to the fact that comparisons are done inline.

#include <algorithm>

std::sort(first, beyond);
std::sort(first, beyond, std::greater<int>());

A Simple Example: Version 3 - iterator adaptors

• Iterators can iterate over streams, either to read elements or to write them.
• cin must be "adapted" to have an iterator interface.

#include <stdlib.h>
#include <iostream>
#include <algorithm>
#include <vector>
#include <iterator>

using namespace std;

int main(int argc, char * argv[])
{
  vector<int> v;
  istream_iterator<int> start(cin), end;
  back_insert_iterator<vector<int> > dest(v);
 
  copy(start, end, dest);
  sort(v.begin(), v.end());
  copy(v.begin(), v.end(), ostream_iterator<int>(cout, "\n"));
  return 0;
}

Adaptors

• Adaptors transform the interface of other types.
• This is very much how electrical adaptors work.

The istream_iterator adaptor

• A template type (of course!); parameterized by the type of object to be read from the stream.
• Initialized with a stream.
• Dereferencing the iterator reads an element from the stream.
• Incrementing the iterator has no effect.
• An istream iterator created with the default constructor has the past-the-end value
  • as does an iterator whose stream has reached the end of file.

Typedefs

• Shorten the length of type definitions.
• Eliminate the problem introduced by overloading the < > operators.

back_insert_iterator<vector<int> > dest(v);

typedef vector<int> int_vector;
back_insert_iterator<int_vector> dest(v);

The copy() algorithm

• Takes three iterators.
  • The first two specify the source range.
  • The third specifies the destination.

typedef istream_iterator<int> int_istream_iterator;
copy(int_istream_iterator(cin), int_istream_iterator(), v.begin());

The back_insert_iterator adaptor

• An iterator that does insertion rather than overwriting.
• Parameterized by the container to insert into.

The ostream_iterator adaptor

• Provides output iterator functionality
• Assigning to the dereferenced iterator will write the data out.
• The ostream_iterator constructor takes two arguments
  • The stream to use
  • The separator.
• Prints the separator between elements.