Standard Template Library

Part of the C++ standard. The most important example for generic programming. Generic programming: make more abstract routines without loosing efficiency using parameterization (both data and algorithm).

// Find the first occurrence of a value
int t[] = { 1, 3, 5, 7, 9, 11, 13, 15, 17, 19 };

int *p = find(t, t + sizeof(t) / sizeof(t[0]), 11);
if(p)
{
  p = 12;
}

// Specific implementation for arrays
int *find(int *begin, int *end, int v)
{
  while (begin != end )
  {
    if (*begin == v)
    {
      return begin;
    }
    ++begin;
  }
  return 0;
}

Generalization

Motivation

Generalization

template <typename T>
T *find(T *begin, T *end, const T& v)
{
  while (begin != end)
  {
    if (*begin == v)
    {
      return begin;
    }
    ++begin;
  }
  return 0;
}

Generalization on type int -> T

Generalization

int t[] = { 1, 3, 5, 7, 9, 11, 13, 15, 17, 19 };

int *p = find(t, t + sizeof(t) / sizeof(t[0]), 11);
if(p)
{
  p = 12;
}

vector<int> v;
v.push_back(1);  v.push_back(3);  v.push_back(5);  v.push_back(7);  v.push_back(9);
v.push_back(11); v.push_back(13); v.push_back(15); v.push_back(17); v.push_back(19);

vector<int>::iterator vi = find(v.begin(), v.end(), 11);
if (vi != v.end())
{
  *vi = 12;
}

list<double> l;
l.push_back(1.1);   l.push_back(3.3);   l.push_back(5.5);   l.push_back(7.7);   l.push_back(9.9);
l.push_back(11.11); l.push_back(13.13); l.push_back(15.15); l.push_back(17.17); l.push_back(19.19);

list<double>::iterator li = find(l.begin(), l.end(), 11.11);
if (li != l.end())
{
  *li = 12.12;
}

Uniform usage

Generalization

const int t[] = { 1, 3, 5, 7, 9, 11, 13, 15, 17, 19 };

const int *pi = find(t, t + sizeof(t) / sizeof(t[0]), 11);
if (pi)
{
  //*pi = 12;      // Syntax error
  cout << *pi;
}

vector<int> v;
v.push_back(1.1);   v.push_back(3.3);   v.push_back(5.5);   v.push_back(7.7);   v.push_back(9.9);
v.push_back(11.11); v.push_back(13.13); v.push_back(15.15); v.push_back(17.17); v.push_back(19.19);

const list<double> cl(v.begin(), v.end());

// const_iterator != const iterator
list<double>::const_iterator cli = find(cl.begin(), cl.end(), 11.11);
if (cli != cl.end())
{
  //*cli = 12.12;  // Syntax error
  cout << *cli;
}

Constant safety

Further generalization

// Find the 3rd occurrence:
list<double> l;
l.push_back(1.1);   l.push_back(3.3);
l.push_back(5.5);   l.push_back(7.7);
l.push_back(9.9);   l.push_back(11.11);
l.push_back(13.13); l.push_back(15.15);
l.push_back(17.17); l.push_back(19.19);

list<double>::iterator li;
li = find(l.begin(), l.end(), 3.14);
li = find(li, l.end(), 3.14);
li = find(li, l.end(), 3.14);

// or: 
li = find(find(find(l.begin(), l.end(), 3.14), 
               l.end(), 3.14), 
          l.end(), 3.14);

Generalization

// Pred1: not too good
bool less55_3rd( int x)
{
  static int cnt = 0;
  if ( x < 55 )
    ++cnt;
  return 3 == cnt;
}

vector<int> v;
v.push_back(1);  v.push_back(3);
v.push_back(5);  v.push_back(7);
v.push_back(9);  v.push_back(11);
v.push_back(13); v.push_back(15);
v.push_back(17); v.push_back(19);

vector<int>::iterator = 
    find_if(v.begin(), v.end(), less55_3rd);
vector<int>::iterator = 
    find_if(v.begin(), v.end(), less55_3rd);

Predicates

Generalization

// Pred2: functor instead of function
struct less55_3rd
{
  less55_3rd() : cnt(0) { }
  bool operator()(int x)
  {
    if ( x < 55 )
      ++cnt;
    return 3 == cnt;
  }
private:
  int cnt;
};

vector<int> v;
v.push_back(1);  v.push_back(3);
v.push_back(5);  v.push_back(7);
v.push_back(9);  v.push_back(11);
v.push_back(13); v.push_back(15);
v.push_back(17); v.push_back(19);

less55_3rd pp;
vector<int>::iterator = 
    find_if(v.begin(), v.end(), pp);

// or:
vector<int>::iterator =
    find_if(v.begin(), v.end(), less55_3rd());

Predicates

Generalization

// Pred3: more generic
template <typename T>
struct less_nth
{
  less_nth(const T& t, int n) 
    : _t(t), _n(n), _cnt(0) { }
  
  bool operator()(const T& t)
  {
    if (t < _t)
      ++cnt;
    return _n == cnt;
  }

private:
  T   _t;
  int _n;
  int _cnt;
};

vector<int> v;
v.push_back(1);  v.push_back(3);
v.push_back(5);  v.push_back(7);
v.push_back(9);  v.push_back(11);
v.push_back(13); v.push_back(15);
v.push_back(17); v.push_back(19);

vector<int>::iterator = 
  find_if(v.begin(), v.end(), 
          less_nth<int>(55,3));

Predicates

Iterators

• all: can be copied and incremented
• input: can be dereferenced as an rvalue, equality comparison
• output: can be dereferenced as an lvalue
• forward: input + output + default constructible
• bidirectional: forward + can be decremented
• random access: bidirectional + arithmetic operators, 
                               inequality comparisons 

Categories

Iterators

• iterator (vanilla)
• constant iterator
• iterator adaptors
  • reverse iterator
  • insert iterators
• stream iterators

Types

Containers

1. Sequential containers
   • vector, deque, list
2. Adapter containers
   • stack, queue, priority_queue
3. Associative containers
   • ordered associative containers
     • set, multiset, map, multimap
   • unordered associative containers (C++11)
     • undered_set, unordered_multiset,
       unordered_map, unordered_multimap

Adapter containers

stack

Op: empty, size, back (->top), push_back (->push), pop_back (->pop)
Cont: deque (default), vector, list

queue

Op: empty, size, front, back, push_back (->push), pop_front (->pop)
Cont: deque (default), list

priority_queue

Op: empty, size, front, push_back (->push), pop_back (->pop)
Cont: vector (default), deque

Ordered associative containers

• Introduced in C++98.
• Elements must be stored in an ordered data structure.
  (Typically red-black trees are used.)
• Asymptotic complexity of all operations are logarithmic compared to the size of the container. 

Unordered associative containers

• Introduced in C++11.
• Elements must be stored based on a hash evaluation, which practically means hash-table.
• Asymptotic complexity of all operations are constant in an average case and linear in the worst case compared to the size of the container.

Container comparison

vector:

•     dynamic array, random access,
•     iterator invalidates: when realloc

deque:

• array of arrays, random access
• iterator invalidates:
  • insertion, and deletion other than front() and back()
  • deleting front() or back() invalidates only iterators referring them
  • it is possible that iterators are invalidated but pointers not

list:

• bidirectional linked list, linear access
• iterator invalidates: only referring to deleted items

ordered associative:

• (typically) red-black tree, logarithmic access
• iterator invalidates: only referring to deleted items

unordered associative:

• hash tables, constant access
• iterator invalidates: only referring to deleted items

Container comparison

Sequential

Container comparison

Ordered associative

Container comparison

Unordered associative