#include <ospace/stl.h>
#include 
int main ()
{
  vector <int> v (5);
  for (int i = 0; i < v.size (); i++)
    v[i] = i + 1;
  int sum = accumulate (v.begin (), v.end (), 0);
  cout << "sum = " << sum << endl;
  return 0;
}

#include <stl.h>
#include 
int mult (int initial_, int element_)
{
  return initial_ * element_;
}
int main ()
{
  vector <int> v (5);
  for (int i = 0; i < v.size (); i++)
    v[i] = i + 1;
  int prod = accumulate (v.begin (), v.end (), 1, mult);
  cout << "prod = " << prod << endl;
  return 0;
}

#include <stl.h>
#include 
#include 
bool str_equal (const char* a_, const char* b_)
{
  return ::strcmp (a_, b_) == 0 ? 1 : 0;
}
char* grades[] = { "A", "B", "C", "D", "F" };
char* letters[] = { "Q", "E", "D" };
int main ()
{
  const unsigned gradeCount = sizeof (grades) / sizeof (grades[0]);
  const unsigned letterCount = sizeof (letters) / sizeof (letters[0]);
  ostream_iterator <char*> iter (cout, "
      ");
  cout << "grades: ";
  copy (grades, grades + gradeCount, iter);
  cout << "\nletters:";
  copy (letters, letters + letterCount, iter);
  cout << endl;
  char** location =
    search (grades, grades + gradeCount,
            letters, letters + letterCount,
            str_equal);
  if (location == grades + gradeCount)
    cout << "letters not found in grades" << endl;
  else
    cout << "letters found in grades at offset: " << location - grades << endl;
  copy (grades + 1, grades + 1 + letterCount, letters);
  cout << "grades: ";
  copy (grades, grades + gradeCount, iter);
  cout << "\nletters:";
  copy (letters, letters + letterCount, iter);
  cout << endl;
  location = search (grades, grades + gradeCount,
                     letters, letters + letterCount,
                     str_equal);
  if (location == grades + gradeCount)
    cout << "letters not found in grades" << endl;
  else
    cout
      << "letters found in grades at offset: " << location - grades << endl;
  return 0;
}

#include <stl.h>
#include 
#include 
bool compare_strings (const char* s1_, const char* s2_)
{
  return ::strcmp (s1_, s2_) < 0 ? 1 : 0;
}
char* names[] = {  "Todd", "Mike", "Graham", "Jack", "Brett"};
int main ()
{
  const unsigned nameSize = sizeof (names)/sizeof (names[0]);
  vector <char*> v1(nameSize);
  for (int i = 0; i < v1.size (); i++)
  {
    v1[i] = names[i];
  }
  vector <char*> v2 (2);
  v2[0] = "foo";
  v2[1] = "bar";
  sort (v1.begin (), v1.end (), compare_strings);
  sort (v2.begin (), v2.end (), compare_strings);
  bool inc = includes (v1.begin (), v1.end (),
                       v2.begin (), v2.end (),
                       compare_strings);
  if (inc)
    cout << "v1 includes v2" << endl;
  else
    cout << "v1 does not include v2" << endl;
  v2[0] = "Brett";
  v2[1] = "Todd";
  inc = includes (v1.begin (), v1.end (),
                  v2.begin (), v2.end (),
                  compare_strings);
  if (inc)
    cout << "v1 includes v2" << endl;
  else
    cout << "v1 does not include v2" << endl;
  return 0;
}

#include <stl.h>
#include 
int main ()
{
  typedef vector <int> IntVec;
  IntVec v1 (10);
  iota (v1.begin (), v1.end (), 0);
  IntVec v2 (3);
  iota (v2.begin (), v2.end (), 50);
  ostream_iterator <int> iter (cout, "
      ");
  cout << "v1: ";
  copy (v1.begin (), v1.end (), iter);
  cout << endl;
  cout << "v2: ";
  copy (v2.begin (), v2.end (), iter);
  cout << endl;
  IntVec::iterator location;
  location = search (v1.begin (), v1.end (), v2.begin (), v2.end ());
  if (location == v1.end ())
    cout << "v2 not contained in v1" << endl;
  else
    cout << "Found v2 in v1 at offset: " << location - v1.begin () << endl;
  iota (v2.begin (), v2.end (), 4);
  cout << "v1: ";
  copy (v1.begin (), v1.end (), iter);
  cout << endl;
  cout << "v2: ";
  copy (v2.begin (), v2.end (), iter);
  cout << endl;
  location = search (v1.begin (), v1.end (), v2.begin (), v2.end ());
  if (location == v1.end ())
    cout << "v2 not contained in v1" << endl;
  else
    cout << "Found v2 in v1 at offset: " << location - v1.begin () << endl;
  return 0;
}

#include 
#include 
#include <stl.h>
typedef vector<char> Line;
void printLine (const Line* line_)
{
  vector<char>::const_iterator i;
  for (i = line_->begin (); i != line_->end (); i++)
   cout << *i;
  cout << endl;
}
int main ()
{
  Line buffer;
  vector<Line*> lines;
  ifstream s ("data.txt");
  s.unsetf (ios::skipws); // Disable white-space skipping.
  istream_iterator it1 (s); // Position at start of file.
  istream_iterator it2; //
      Serves as "past-the-end" marker.
  copy (it1, it2, back_inserter (buffer));
  Line::iterator i = buffer.begin ();
  Line::iterator p;
  while (i != buffer.end ())
  {
    p = find (i, buffer.end (), '\n');
    lines.push_back (new Line (i, p));
    i = ++p;
  }
  sort (lines.begin (), lines.end (), less_p<Line*> ());
  cout << "Read " << lines.size () << " lines" << endl;
  vector<Line*>::iterator j;
  for (j = lines.begin (); j != lines.end (); j++)
    printLine (*j);
  release (lines.begin (), lines.end ()); // Release memory.
  return 0;
}

#include <stl.h>
#include <ospace/stl/examples/myaloc.h>
int main ()
{
  {
    cout << "vectors:" << endl;
    os_my_allocator<int> alloc;
    vector<int> v3 (alloc);
    v3.push_back (42);
    vector<int> v4 (alloc);
    v4.push_back (42);
  }
  {
    cout << "bit_vectors:" << endl;
    os_my_allocator<unsigned int> alloc;
    bit_vector v1 (alloc);
    v1.push_back (1);
  }
  {
    cout << "deques:" << endl;
    os_my_allocator<int> alloc;
    deque<int> d (alloc);
    d.push_back (42);
  }
  {
    cout << "lists:" << endl;
    os_my_allocator<os_list_node<int> > alloc;
    list<int> l (alloc);
    l.push_back (42);
  }
  {
    cout << "sets:" << endl;
    os_my_allocator<os_value_node<int> > alloc;
    set<int, less<int> > s (alloc);
    s.insert (42);
  }
  {
    cout << "maps" << endl;
    os_my_allocator<os_value_node<os_pair<const int, float> > > alloc;
    map<int, float, less<int> > m (alloc);
    m[4] = 2.0;
  }
  return 0;
}

#include <stl.h>
#include 
class X
{
  public:
    X (int i_) : i (i_) {}
    ~X () { cout << "Delete X(" << i << ")" << endl; }
    int i;
};
ostream& operator << (ostream& stream_, const X& x_)
{
  return stream_ << "X(" << x_.i << ")";
}
int main ()
{
  vector<X*> v;
  v.push_back (new X (2));
  v.push_back (new X (1));
  v.push_back (new X (4));
  vector<X*>::iterator i;
  cout << "Initial contents:" << endl;
  for (i = v.begin (); i != v.end (); i++)
    cout << " " << *(*i) << endl;
  release (v.begin ()); // Delete the first heap-based object.
  v.erase (v.begin ()); // Erase the first element. 
  cout << "Remaining contents:" << endl;
  for (i = v.begin (); i != v.end (); i++)
    cout << " " << *(*i) << endl;
  release (v.begin (), v.end ()); // Delete remaining heap-based
      objects.
  v.erase (v.begin (), v.end ()); // Erase remaining elements.
  return 0;
}

#include 
#include <stl.h>
int main ()
{
  typedef map<char, int, less<char> > maptype;
  maptype m;
  // Store mappings between roman numerals and decimals.
  m['l'] = 50;
  m['x'] = 20; //
      Deliberate mistake.
  m['v'] = 5;
  m['i'] = 1;
  cout << "m['x'] = " << m['x'] << endl;
  m['x'] = 10; //
      Correct mistake.
  cout << "m['x'] = " << m['x'] << endl;
  cout << "m['z'] = " << m['z'] << endl; // Note default value is added.
  cout << "m.count ('z') = " << m.count ('z') << endl;
  pair<maptype::iterator, bool> p;
  p = m.insert (pair<const char, int> ('c', 100));
  if (p.second)
    cout << "First insertion successful" << endl;
  p = m.insert (pair<const char, int> ('c', 100));
  if (p.second)
    cout << "Second insertion successful" << endl;
  else
    cout << "Existing pair " << (*(p.first)).first
         << " -> " << (*(p.first)).second << endl;
  return 0;
}

#include <stl.h>
#include 
#include 
bool str_equal (const char* a_, const char* b_)
{
  return ::strcmp (a_, b_) == 0 ? 1 : 0;
}
const unsigned size = 5;
char* n1[size] = { "Brett", "Graham", "Jack", "Mike", "Todd" };
int main ()
{
  char* n2[size];
  copy (n1, n1 + 5, n2);
  pair <char**, char**> result;
  result = mismatch (n1, n1+ size, n2, str_equal);
  if (result.first == n1 + size && result.second == n2 + size)
    cout << "n1 and n2 are the same" << endl;
  else
    cout << "mismatch at index: " << (result.first - n1) << endl;
  n2[2] = "QED";
  result = mismatch (n1, n1 + size, n2, str_equal);
  if (result.first == n2 + size && result.second == n2 + size)
    cout << "n1 and n2 are the same" << endl;
  else
    cout << "mismatch at index: " << (result.first - n1) << endl;
  return 0;
}

#include <stl.h>
#include 
int main ()
{
  typedef vector<int> IntVec;
  IntVec v1 (10);
  IntVec v2 (v1.size ());
  iota (v1.begin (), v1.end (), 0);
  iota (v2.begin (), v2.end (), 0);
  pair <IntVec::iterator, IntVec::iterator> result;
  result = mismatch (v1.begin (), v1.end (), v2.begin ());
  if (result.first == v1.end () && result.second == v2.end ())
    cout << "v1 and v2 are the same" << endl;
  else
    cout << "mismatch at index: " << (result.first - v1.begin ()) << endl;
  v2[v2.size()/2] = 42;
  result = mismatch (v1.begin (), v1.end (), v2.begin ());
  if (result.first == v1.end () && result.second == v2.end ())
    cout << "v1 and v2 are the same" << endl;
  else
    cout << "mismatch at index: " << (result.first - v1.begin ()) << endl;
  return 0;
}

#include 
#include <stl.h>
typedef multimap<int, char, less<int> > mmap;
typedef pair<const int, char> pair_type;
pair_type p1 (3, 'c');
pair_type p2 (6, 'f');
pair_type p3 (1, 'a');
pair_type p4 (2, 'b');
pair_type p5 (3, 'x');
pair_type p6 (6, 'f');
pair_type array [] =
  {
    p1,
    p2,
    p3,
    p4,
    p5,
    p6
  };
int main ()
{
  mmap m (array, array + 7);
  mmap::iterator i;
  // Return location of first element that is not less than 3
  i = m.lower_bound (3);
  cout << "lower bound:" << endl;
  cout << (*i).first << " -> " << (*i).second << endl;
  // Return location of first element that is greater than 3
  i = m.upper_bound (3);
  cout << "upper bound:" << endl;
  cout << (*i).first << " -> " << (*i).second << endl;
  return 0;
}

#include <stl.h>
#include 
#include 
typedef vector <char*> CStrVector;
int equal_length (const char* v1_, const char* v2_)
{
  return ::strlen (v1_) == ::strlen(v2_);
}
char* names[] = { "Brett", "Graham", "Jack", "Mike", "Todd" };
int main ()
{
  const int nameCount = sizeof (names)/sizeof(names[0]);
  CStrVector v (nameCount);
  for (int i = 0; i < nameCount; i++)
    v[i] = names[i];
  CStrVector::iterator location;
  location = adjacent_find (v.begin (), v.end (), equal_length);
  if (location != v.end ())
    cout
      << "Found two adjacent strings of equal length: "
      << *location
      << " -and- "
      << *(location + 1)
      << endl;
  else
    cout << "Didn't find two adjacent strings of equal length.";
  return 0;
}

#include 
#include <stl.h>
char array [] = { 'x', 'l', 'x', 't', 's', 's' };
int main ()
{
  list<char> str (array, array + 6);
  list<char>::iterator i;
  cout << "original: ";
  for (i = str.begin (); i != str.end (); i++)
    cout << *i;
  cout << endl;
  cout << "reversed: ";
  str.reverse ();
  for (i = str.begin (); i != str.end (); i++)
    cout << *i;
  cout << endl;
  cout << "removed: ";
  str.remove ('x');
  for (i = str.begin (); i != str.end (); i++)
    cout << *i;
  cout << endl;
  cout << "uniqued: ";
  str.unique ();
  for (i = str.begin (); i != str.end (); i++)
    cout << *i;
  cout << endl;
  cout << "sorted: ";
  str.sort ();
  for (i = str.begin (); i != str.end (); i++)
    cout << *i;
  cout << endl;
  return 0;
}

#include <stl.h>
#include 
#include 
bool str_compare (const char* a_, const char* b_)
{
  return ::strcmp (a_, b_) < 0 ? 1 : 0;
}
char* names[] = { "aa", "ff", "dd", "ee", "cc", "bb" };
int main ()
{
  const unsigned nameSize = sizeof (names) / sizeof (names[0]);
  vector <char*> v1 (nameSize);
  for (int i = 0; i < v1.size (); i++)
    v1[i] = names[i];
  ostream_iterator<char*> iter (cout, "
      ");
  copy (v1.begin (), v1.end (), iter);
  cout << endl;
  vector <char*> result (5);
  partial_sort_copy (v1.begin (),
                     v1.end (),
                     result.begin (),
                     result.end (),
                     str_compare);
  copy (v1.begin (), v1.end (), iter);
  cout << endl;
  return 0;
}

#include 
#include <stl.h>
int array [] = { 1, 4, 9, 16, 25, 36 };
int main ()
{
  vector<int> v (array, array + 6);
  for (int i = 0; i < v.size (); i++)
    cout << "v[" << i << "]
        = " << v[i] << endl;
  cout << endl;
  v.erase (v.begin ()); // Erase first element.
  for (i = 0; i < v.size (); i++)
    cout << "v[" << i << "]
        = " << v[i] << endl;
  cout << endl;
  v.erase (v.end () - 1); // Erase last
      element.
  for (i = 0; i < v.size (); i++)
    cout << "v[" << i << "]
        = " << v[i] << endl;
  cout << endl;
  v.erase (v.begin () + 1, v.end () - 1); // Erase all but first and last.
  for (i = 0; i < v.size (); i++)
    cout << "v[" << i << "]
        = " << v[i] << endl;
  cout << endl;
  v.erase (); // Erase all.
  return 0;
}

#include <stl.h>
#include 
#include 
int add (int a_, int b_)
{
  return a_ + b_;
}
int mult (int a_, int b_)
{
  return a_ * b_;
}
int main ()
{
  vector <int> v1 (3);
  vector <int> v2 (v1.size ());
  for (int i = 0; i < v1.size (); i++)
  {
    v1[i] = i + 1;
    v2[i] = v1.size () - i;
  }
  ostream_iterator<int> iter (cout, "
      ");
  cout << "Inner product (product of sums):\n\t";
  copy (v1.begin (), v1.end (), iter);
  cout << "\n\t";
  copy (v2.begin (), v2.end (), iter);
  int result =
    inner_product (v1.begin (), v1.end (),
                   v2.begin (),
                   1,
                   mult, add);
  cout << "\nis: " << result << endl;
  return 0;
}

#include 
#include <stl.h>
int main ()
{
  typedef multimap<char, int, less<char> > mmap;
  mmap m;
  cout << "count ('X') = " << m.count ('X') << endl;
  m.insert (pair<const char, int> ('X', 10)); //
          Standard way.
  cout << "count ('X') = " << m.count ('X') << endl;
  m.insert ('X', 20); // Non-standard, but very convenient!
  cout << "count ('X') = " << m.count ('X') << endl;
  m.insert ('Y', 32);
  mmap::iterator i = m.find ('X'); //
      Find first match.
  while (i != m.end ()) // Loop until
      end is reached.
  {
    cout << (*i).first << " -> " << (*i).second << endl;
    i++;
  }
  int count = m.erase ('X');
  cout << "Erased " << count << " items" << endl;
  return 0;
}

#include <stl.h>
#include 
int numbers1 [5] = { 1, 2, 4, 8, 16 };
int numbers2 [5] = { 5, 3, 2, 1, 1 };
int main ()
{
  int* location = adjacent_find (numbers1, numbers1 + 5);
  if (location != numbers1 + 5)
    cout
      << "Found adjacent pair of: "
      << *location
      << " at offset "
      << (location - numbers1)
      << endl;
  else
    cout << "No adjacent pairs" << endl;
  location = adjacent_find (numbers2, numbers2 + 5);
  if (location != numbers2 + 5)
    cout
      << "Found adjacent pair of: "
      << *location
      << " at offset "
      << (location - numbers2)
      << endl;
  else
    cout << "No adjacent pairs" << endl;
  return 0;
}

#include <stl.h>
#include 
#include 
bool str_compare (const char* a_, const char* b_)
{
  return ::strcmp (a_, b_) < 0 ? 1 : 0;
}
char* names[] = { "aa", "ff", "dd", "ee", "cc", "bb" };
int main ()
{
  const unsigned nameSize = sizeof (names) / sizeof (names[0]);
  vector <char*> v1 (nameSize);
  for (int i = 0; i < v1.size (); i++)
    v1[i] = names[i];
  ostream_iterator<char*> iter (cout, "
      ");
  copy (v1.begin (), v1.end (), iter);
  cout << endl;
  partial_sort (v1.begin (),
                v1.begin () + nameSize / 2,
                v1.end (),
                str_compare);
  copy (v1.begin (), v1.end (), iter);
  cout << endl;
  return 0;
}

#include 
#include <stl.h>
bool less_than (int a_, int b_)
{
  return a_ < b_;
}
bool greater_than (int a_, int b_)
{
  return a_ > b_;
}
int array [] = { 3, 6, 1, 9 };
int main ()
{
  typedef pointer_to_binary_function<int, int, bool> fn_type;
  typedef multiset<int, fn_type> mset;
  fn_type f (less_than);
  mset s1 (array, array + 4, f);
  mset::const_iterator i = s1.begin ();
  cout << "Using less_than: " << endl;
  while (i != s1.end ())
    cout << *i++ << endl;
  fn_type g (greater_than);
  mset s2 (array, array + 4, g);
  i = s2.begin ();
  cout << "Using greater_than: " << endl;
  while (i != s2.end ())
    cout << *i++ << endl;
  return 0;
}

#include 
#include <stl.h>
int main ()
{
  typedef multiset<int, less<int> > mset;
  mset s;
  cout << "count (42) = " << s.count (42) << endl;
  s.insert (42);
  cout << "count (42) = " << s.count (42) << endl;
  s.insert (42);
  cout << "count (42) = " << s.count (42) << endl;
  set<int, less<int> >::iterator i = s.find (40);
  if (i == s.end ())
    cout << "40 Not found" << endl;
  else
    cout << "Found " << *i << endl;
  i = s.find (42);
  if (i == s.end ())
    cout << "Not found" << endl;
  else
    cout << "Found " << *i << endl;
  int count = s.erase (42);
  cout << "Erased " << count << " instances" << endl;
  return 0;
}

#include 
#include <stl.h>
void print (vector<double>& vector_)
{
  for (int i = 0; i < vector_.size (); i++)
    cout << vector_[i] << " ";
  cout << endl;
}
int main ()
{
  vector<double> v1; // Empty
      vector of doubles.
  v1.push_back (32.1);
  v1.push_back (40.5);
  vector<double> v2; // Another
      empty vector of doubles.
  v2.push_back (3.56);
  cout << "v1 = ";
  print (v1);
  cout << "v2 = ";
  print (v2);
  v1.swap (v2); // Swap the vector's contents.
  cout << "v1 = ";
  print (v1);
  cout << "v2 = ";
  print (v2);
  v2 = v1; // Assign one vector to another.
  cout << "v2 = ";
  print (v2);
  return 0;
}

#include <stl.h>
#include 
#include 
bool str_equal (const char* a_, const char* b_)
{
  return ::strcmp (a_, b_) == 0 ? 1 : 0;
}
char* labels[] = { "Q","Q","W","W","E","E","R","T","T","Y","Y" };
int main ()
{
  const unsigned count = sizeof (labels) / sizeof (labels[0]);
  ostream_iterator <char*> iter (cout);
  copy (labels, labels + count, iter);
  cout << endl;
  char* uCopy[count];
  fill (uCopy, uCopy + count, "");
  unique_copy (labels, labels + count, uCopy, str_equal);
  copy (labels, labels + count, iter);
  cout << endl;
  copy (uCopy, uCopy + count, iter);
  cout << endl;
  return 0;
}

#include <stl.h>
#include 
int n1[5] = { 1, 2, 3, 4, 5 };
int n2[5] = { 1, 2, 3, 4, 5 };
int n3[5] = { 1, 2, 3, 2, 1 };
int main ()
{
  pair <int*, int*> result;
  result = mismatch (n1, n1 + 5, n2);
  if (result.first == (n1 + 5) && result.second == (n2 + 5))
    cout << "n1 and n2 are the same" << endl;
  else
    cout << "Mismatch at offset: " << (result.first - n1) << endl;
  result = mismatch (n1, n1 + 5, n3);
  if (result.first == (n1 + 5) && result.second == (n3 + 5))
    cout << "n1 and n3 are the same" << endl;
  else
    cout << "Mismatch at offset: " << (result.first - n1) << endl;
  return 0;
}

#include <stl.h>
#include 
#include 
class MyRandomGenerator
{
  public:
    unsigned long operator () (unsigned
        long n_);
};
unsigned long
MyRandomGenerator::operator () (unsigned
    long n_)
{
  return rand () % n_;
}
int main ()
{
  vector <int> v1(10);
  iota (v1.begin (), v1.end (), 0);
  ostream_iterator <int> iter (cout, "
      ");
  copy (v1.begin (), v1.end (), iter);
  cout << endl;
  MyRandomGenerator r;
  for (int i = 0; i < 3; i++)
  {
    random_shuffle (v1.begin (), v1.end (), r);
    copy (v1.begin (), v1.end (), iter);
    cout << endl;
  }
  return 0;
}

#include <stl.h>
#include 
int main ()
{
  vector <int> v1 (5);
  vector <int> v2 (v1.size ());
  for (int i = 0; i < v1.size (); i++)
  {
    v1[i] = 10 - i;
    v2[i] =  7 - i;
  }
  vector <int> result (v1.size () + v2.size ());
  merge (v1.begin (), v1.end (),
         v2.begin (), v2.end (),
         result.begin (),
         greater<int>() );
  ostream_iterator <int> iter (cout, "
      ");
  copy (v1.begin (), v1.end (), iter);
  cout << endl;
  copy (v2.begin (), v2.end (), iter);
  cout << endl;
  copy (result.begin (), result.end (), iter);
  cout << endl;
  return 0;
}

#include <stl.h>
#include 
int main ()
{
  typedef vector<int> IntVector;
  IntVector v (10);
  for (int i = 0; i < v.size (); i++)
    v[i] = i;
  IntVector::iterator location;
  location = adjacent_find (v.begin (), v.end ());
  if (location != v.end ())
    cout << "Found adjacent pair of: " << *location << endl;
  else
    cout << "No adjacent pairs" << endl;
  v[6] = 7;
  location = adjacent_find (v.begin (), v.end ());
  if (location != v.end ())
    cout << "Found adjacent pair of: " << *location << endl;
  else
    cout << "No adjacent pairs" << endl;
  return 0;
}

#include 
#include <stl.h>
int array1 [] = { 1, 4, 25 };
int array2 [] = { 9, 16 };
int main ()
{
  vector<int> v (array1, array1 + 3);
  v.insert (v.begin (), 0); // Insert
      before first element.
  v.insert (v.end (), 36); // Insert
      after last element.
  for (int i = 0; i < v.size (); i++)
    cout << "v[" << i << "]
        = " << v[i] << endl;
  cout << endl;
  // Insert contents of array2 before fourth element.
  v.insert (v.begin () + 3, array2, array2 + 2);
  for (i = 0; i < v.size (); i++)
    cout << "v[" << i << "]
        = " << v[i] << endl;
  cout << endl;
  return 0;
}

#include 
#include <stl.h>
struct odd : public unary_function<int, bool>
{
  odd () {}
  bool operator () (int n_) const { return (n_ % 2) == 1; }
};
struct positive : public unary_function<int, bool>
{
  positive () {}
  bool operator () (int n_) const { return n_ >= 0; }
};
int array [6] = { -2, -1, 0, 1, 2, 3 };
int main ()
{ 
  binary_compose<logical_and<bool>, odd, positive> 
    b (logical_and<bool> (), odd (), positive ());
  int* p = find_if (array, array + 6, b);
  if (p != array + 6)
    cout << *p << " is odd and positive" << endl;
  return 0;
}

#include <stl.h>
#include 
#include 
char* word1 = "ABCDEFGHIJKLMNO";
char* word2 = "LMNOPQRSTUVWXYZ";
int main ()
{
  ostream_iterator <char> iter (cout, "
      ");
  cout << "word1: ";
  copy (word1, word1 + ::strlen (word1), iter);
  cout << "\nword2: ";
  copy (word2, word2 + ::strlen (word2), iter);
  cout << endl;
  set_symmetric_difference (word1, word1 + ::strlen (word1),
                            word2, word2 + ::strlen (word2),
                            iter,
                            less<char>());
  cout << endl;
  return 0;
}

#include <stl.h>
#include 
int v1[6] = { 1, 1, 2, 3, 5, 8 };
int v2[6] = { 0, 1, 2, 3, 4, 5 };
int v3[2] = { 3, 4 };
int main ()
{
  int* location;
  location = search (v1, v1 + 6, v3, v3 + 2);
  if (location == v1 + 6)
    cout << "v3 not contained in v1" << endl;
  else
    cout << "Found v3 in v1 at offset: " << location - v1 << endl;
  location = search (v2, v2 + 6, v3, v3 + 2);
  if (location == v2 + 6)
    cout << "v3 not contained in v2" << endl;
  else
    cout << "Found v3 in v2 at offset: " << location - v2 << endl;
  return 0;
}

#include <stl.h>
#include 
int main ()
{
  typedef vector <int> IntVec;
  IntVec v (10);
  for (int i = 0; i < v.size (); i++)
    v[i] = i / 3;
  ostream_iterator<int> iter (cout, "
      ");
  cout << "Within the collection:\n\t";
  copy (v.begin (), v.end (), iter);
  pair <IntVec::iterator, IntVec::iterator> range;
  range = equal_range (v.begin (), v.end (), 2);
  cout
    << "\n2 can be inserted from before index "
    << (range.first - v.begin ())
    << " to before index "
    << (range.second - v.begin ())
    << endl;
  return 0;
}

#include <stl.h>
#include 
int main ()
{
  vector <int> v1 (10);
  iota (v1.begin (), v1.end (), 0);
  ostream_iterator <int> iter (cout, "
      ");
  copy (v1.begin (), v1.end (), iter);
  cout << endl;
  vector <int> v2 (v1.size ());
  for (int i = 0; i < v1.size (); i++)
  {
    rotate_copy (v1.begin (),
                 v1.begin () + i,
                 v1.end (),
                 v2.begin ());
    ostream_iterator <int> iter (cout, "
        ");
    copy (v2.begin (), v2.end (), iter);
    cout << endl;
  }
  cout << endl;
  return 0;
}

#include <stl.h>
#include 
#include 
char chars[] = "aabbccddggghhklllmqqqqssyyzz";
int main ()
{
  const unsigned count = sizeof (chars) - 1;
  ostream_iterator<char> iter (cout);
  cout << "Within the collection:\n\t";
  copy (chars, chars + count, iter);
  pair <char*, char*> range;
  range = equal_range (chars, chars + count, 'q', less<char>());
  cout
    << "\nq can be inserted from before index "
    << (range.first - chars)
    << " to before index "
    << (range.second - chars)
    << endl;
  return 0;
}

#include <stl.h>
#include 
class X
{
  public:
    X (int i_) : i (i_) {}
    ~X () { cout << "Delete X(" << i << ")" << endl; }
    int i;
};
ostream& operator << (ostream& stream_, const X& x_)
{
  return stream_ << "X(" << x_.i << ")";
}
int main ()
{
  vector<X*> v;
  v.push_back (new X (2));
  v.push_back (new X (1));
  v.push_back (new X (4));
  vector<X*>::iterator i;
  for (i = v.begin (); i != v.end (); i++)
    cout << *(*i) << endl;
  release (v.begin (), v.end ()); // Delete heap-based objects.
  return 0;
}

#include <stl.h>
#include 
int main ()
{
  vector<int> v1(10);
  vector<int> v2(3);
  for (int i = 0; i < v1.size (); i++)
  {
    v1[i] = i;
  }
  if (includes (v1.begin (), v1.end (), v2.begin (), v2.end ()))
    cout << "v1 includes v2" << endl;
  else
    cout << "v1 does not include v2" << endl;
  for (i = 0; i < v2.size (); i++)
    v2[i] = i + 3;
  if (includes (v1.begin (), v1.end (), v2.begin (), v2.end ()))
    cout << "v1 includes v2" << endl;
  else
    cout << "v1 does not include v2" << endl;
  return 0;
}

#include <stl.h>
#include 
#include 
char* word1 = "ABCDEFGHIJKLMNO";
char* word2 = "LMNOPQRSTUVWXYZ";
int main ()
{
  ostream_iterator <char> iter (cout, "
      ");
  cout << "word1: ";
  copy (word1, word1 + ::strlen (word1), iter);
  cout << "\nword2: ";
  copy (word2, word2 + ::strlen (word2), iter);
  cout << endl;
  set_intersection (word1, word1 + ::strlen (word1),
                    word2, word2 + ::strlen (word2),
                    iter,
                    less<char>());
  cout << endl;
  return 0;
}

#include <stl.h>
#include 
#include 
int main ()
{
  vector <int> v1 (3);
  vector <int> v2 (v1.size ());
  for (int i = 0; i < v1.size (); i++)
  {
    v1[i] = i + 1;
    v2[i] = v1.size () - i;
  }
  ostream_iterator<int> iter (cout, "
      ");
  cout << "Inner product (sum of products) of:\n\t";
  copy (v1.begin (), v1.end (), iter);
  cout << "\n\t";
  copy (v2.begin (), v2.end (), iter);
  int result = inner_product (v1.begin (), v1.end (), v2.begin (), 0);
  cout << "\nis: " << result << endl;
  return 0;
}

#include <stl.h>
#include 
int main ()
{
  vector <int> v1 (5);
  vector <int> v2 (v1.size ());
  iota (v1.begin (), v1.end (), 0);
  iota (v2.begin (), v2.end (), 3);
  vector <int> result (v1.size () + v2.size ());
  merge (v1.begin (), v1.end (), v2.begin (), v2.end (), result.begin ());
  ostream_iterator <int> iter (cout, "
      ");
  copy (v1.begin (), v1.end (), iter);
  cout << endl;
  copy (v2.begin (), v2.end (), iter);
  cout << endl;
  copy (result.begin (), result.end (), iter);
  cout << endl;
  return 0;
}

#include 
#include <stl.h>
struct odd : public unary_function<int, bool>
{
  odd () {}
  bool operator () (int n_) const { return (n_ % 2) == 1; }
};
struct positive : public unary_function<int, bool>
{
  positive () {}
  bool operator () (int n_) const { return n_ >= 0; }
};
int array [6] = { -2, -1 , 0, 1, 2, 3 };
int main ()
{
  int* p = find_if (array, array + 6, 
    compose2 (logical_and<bool> (), odd (), positive ()));
  if (p != array + 6)
    cout << *p << " is odd and positive" << endl;
  return 0;
}

#include <stl.h>
// Compile this code without defining OS_USE_EXCEPTIONS.
void my_handler (int code_, const char* str_)
{
  cout << "Caught " << str_ << " code " << code_ << "" << endl;
}
int main ()
{
  os_handler_function_t old_h = os_set_error_handler (my_handler);
  vector<int> v;
  v.pop_back (); // Generates an empty object error.
  cout << "returned from pop_back()" << endl;
  os_set_error_handler (old_h);
  v.pop_back (); // Generates an empty object error.
  cout << "successful termination" << endl;
  return 0;
}

#include <stl.h>
#include 
int numbers1[5] = { 1, 2, 3, 4, 5 };
int numbers2[5] = { 1, 2, 4, 8, 16 };
int numbers3[2] = { 4, 8 };
int main ()
{
  if (includes (numbers1, numbers1 + 5, numbers3, numbers3 + 2))
    cout << "numbers1 includes numbers3" << endl;
  else
    cout << "numbers1 does not include numbers3" << endl;
  if (includes (numbers2, numbers2 + 5, numbers3, numbers3 + 2))
    cout << "numbers2 includes numbers3" << endl;
  else
    cout << "numbers2 does not include numbers3" << endl;
  return 0;
}

#include <stl.h>
#include 
#include 
char* word1 = "ABCDEFGHIJKLMNO";
char* word2 = "LMNOPQRSTUVWXYZ";
int main ()
{
  ostream_iterator <char> iter (cout, "
      ");
  cout << "word1: ";
  copy (word1, word1 + ::strlen (word1), iter);
  cout << "\nword2: ";
  copy (word2, word2 + ::strlen (word2), iter);
  cout << endl;
  set_difference (word1, word1 + ::strlen (word1),
                  word2, word2 + ::strlen (word2),
                  iter,
                  less<char>());
  cout << endl;
  return 0;
}

#include <stl.h>
#include 
#include 
char* word1 = "ABCDEFGHIJKLMNO";
char* word2 = "LMNOPQRSTUVWXYZ";
int main ()
{
  ostream_iterator <char> iter (cout, "
      ");
  cout << "word1: ";
  copy (word1, word1 + ::strlen (word1), iter);
  cout << "\nword2: ";
  copy (word2, word2 + ::strlen (word2), iter);
  cout << endl;
  set_union (word1, word1 + ::strlen (word1),
             word2, word2 + ::strlen (word2),
             iter,
             less<char>());
  cout << endl;
  return 0;
}

#include <stl.h>
#include 
#include 
bool str_equal (const char* a_, const char* b_)
{
  return ::strcmp (a_, b_) == 0 ? 1 : 0;
}
char* labels[] = { "Q","Q","W","W","E","E","R","T","T","Y","Y" };
int main ()
{
  const unsigned count = sizeof (labels) / sizeof (labels[0]);
  ostream_iterator <char*> iter (cout);
  copy (labels, labels + count, iter);
  cout << endl;
  unique (labels, labels + count, str_equal);
  copy (labels, labels + count, iter);
  cout << endl;
  return 0;
}

#include <stl.h>
#include 
#include 
int main ()
{
  vector <int> v1 (10);
  for (int i = 0; i < v1.size (); i++)
    v1[i] = rand () % 10;
  vector <int> result (5);
  ostream_iterator<int> iter (cout, "
      ");
  copy (v1.begin (), v1.end (), iter);
  cout << endl;
  partial_sort_copy (v1.begin (),
                     v1.end (),
                     result.begin (),
                     result.end ());
  copy (result.begin (), result.end (), iter);
  cout << endl;
  return 0;
}

#include <stl.h>
#include 
int main ()
{
  vector <int> v1 (10);
  for (int i = 0; i < v1.size (); i++)
    v1[i] = i;
  vector <int> v2 (10);
  if (equal (v1.begin (), v1.end (), v2.begin ()))
    cout << "v1 is equal to v2" << endl;
  else
    cout << "v1 is not equal to v2" << endl;
  copy (v1.begin (), v1.end (), v2.begin ());
  if (equal (v1.begin (), v1.end (), v2.begin ()))
    cout << "v1 is equal to v2" << endl;
  else
    cout << "v1 is not equal to v2" << endl;
  return 0;
}

#include <stl.h>
#include 
int numbers1[5] = { 1, 2, 3, 4, 5 };
int numbers2[5] = { 1, 2, 4, 8, 16 };
int numbers3[2] = { 1, 2 };
int main ()
{
  if (equal (numbers1, numbers1 + 5, numbers2))
    cout << "numbers1 is equal to numbers2" << endl;
  else
    cout << "numbers1 is not equal to numbers2" << endl;
  if (equal (numbers3, numbers3 + 2, numbers1))
    cout << "numbers3 is equal to numbers1" << endl;
  else
    cout << "numbers3 is not equal to numbers1" << endl;
  return 0;
}

#include <stl.h>
#include 
#include 
class Fibonacci
{
  public:
    Fibonacci () : v1 (0), v2 (1) {}
    int operator () ();
  private:
    int v1;
    int v2;
};
int
Fibonacci::operator () ()
{
  int r = v1 + v2;
  v1 = v2;
  v2 = r;
  return v1;
}
int main ()
{
  vector <int> v1 (10);
  Fibonacci generator;
  generate_n (v1.begin (), v1.size (), generator);
  ostream_iterator<int> iter (cout, "
      ");
  copy (v1.begin (), v1.end (), iter);
  cout << endl;
  return 0;
}

#include <stl.h>
#include 
#include 
class Fibonacci
{
  public:
    Fibonacci () : v1 (0), v2 (1) {}
    int operator () ();
  private:
    int v1;
    int v2;
};
int
Fibonacci::operator () ()
{
  int r = v1 + v2;
  v1 = v2;
  v2 = r;
  return v1;
}
int main ()
{
  vector <int> v1 (10);
  Fibonacci generator;
  generate (v1.begin (), v1.end (), generator);
  ostream_iterator<int> iter (cout, "
      ");
  copy (v1.begin (), v1.end (), iter);
  cout << endl;
  return 0;
}

#include <stl.h>
#include 
bool odd (int a_)
{
  return a_ % 2;
}
int main ()
{
  vector <int> v1 (10);
  for (int i = 0; i < v1.size (); i++)
    v1[i] = i % 5;
  ostream_iterator <int> iter (cout, "
      ");
  copy (v1.begin (), v1.end (), iter);
  cout << endl;
  vector <int> v2 (v1.size ());
  replace_copy_if (v1.begin (), v1.end (), v2.begin (), odd, 42);
  copy (v1.begin (), v1.end (), iter);
  cout << endl;
  copy (v2.begin (), v2.end (), iter);
  cout << endl;
  return 0;
}

#include 
#include <stl.h>
int main ()
{
  deque<int> d;
  d.push_back (4); // Add after end.
  d.push_back (9);
  d.push_back (16);
  d.push_front (1); // Insert at beginning.
  for (int i = 0; i < d.size (); i++)
    cout << "d[" << i << "]
        = " << d[i] << endl;
  cout << endl;
  d.pop_front (); // Erase first element.
  d[2] = 25; //
      Replace last element.
  for (i = 0; i < d.size (); i++)
    cout << "d[" << i << "]
        = " << d[i] << endl;
  return 0;
}

#include <stl.h>
#include 
bool div_3 (int a_)
{
  return a_ % 3 ? 0 : 1;
}
int main ()
{
  typedef vector <int> IntVec;
  IntVec v (10);
  for (int i = 0; i < v.size (); i++)
    v[i] = (i + 1) * (i + 1);
  IntVec::iterator iter;
  iter = find_if (v.begin (), v.end (), div_3);
  if (iter != v.end ())
    cout
      << "Value "
      << *iter
      << " at offset "
      << (iter - v.begin ())
      << " is divisible by 3"
      << endl;
  return 0;
}

#include 
#include <math.h>
#include <stl.h>
struct square_root : public unary_function<double, double>
{
  square_root () {}
  double operator () (double x_) const { return sqrt (x_); }
};
int input [3] = { -1, -4, -16 };
int main ()
{ 
  int output [3];
  transform (input, input + 3, output, 
    unary_compose<square_root, negate<int> > (square_root (), negate<int> ()));
  for (int i = 0; i < 3; i++)
    cout << output[i] << endl;
  return 0;
}

#include 
#include <stl.h>
class X
{
  public:
    X (int i_ = 0) : i (i_) {}
    operator int () const { return i; }
  private:
    int i;
};
int main ()
{
  os_heap_allocator<X> a;
  // Allocate (but do not construct) storage for 5 elements.
  os_heap_allocator<X>::pointer p = a.allocate (5); 
  raw_storage_iterator<X*, X> r (p);
  for (int i = 0; i < 5; i++)
    *r++ = X (i);
  for (i = 0; i < 5; i++)
    cout << *p++ << endl;
  return 0;
}

#include 
#include <stl.h>
int main ()
{
  set<int, less<int> > s;
  pair<set<int, less<int> >::const_iterator, bool> p;
  p = s.insert (42);
  if (p.second)
   cout << "Inserted new element " << *(p.first) << endl;
  else
   cout << "Existing element = " << *(p.first) << endl;
  p = s.insert (42);
  if (p.second)
   cout << "Inserted new element " << *(p.first) << endl;
  else
   cout << "Existing element = " << *(p.first) << endl;
  return 0;
}

#include 
#include <stl.h>
int array [] = { 3, 6, 1, 2, 3, 2, 6, 7, 9 };
int main ()
{
  multiset<int, less<int> > s (array, array + 9);
  multiset<int, less<int> >::iterator i;
  // Return location of first element that is not less than 3
  i = s.lower_bound (3);
  cout << "lower bound = " << *i << endl;
  // Return location of first element that is greater than 3
  i = s.upper_bound (3);
  cout << "upper bound = " << *i << endl;
  return 0;
}

#include <stl.h>
#include 
#include 
bool str_compare (const char* a_, const char* b_)
{
  return ::strcmp (a_, b_) < 0 ? 1 : 0;
}
char* labels[] = { "aa", "dd", "ff", "jj", "ss", "zz" };
int main ()
{
  const unsigned count = sizeof (labels) / sizeof (labels[0]);
  if (binary_search (labels, labels + count, "ff", str_compare))
    cout << "ff is in labels." << endl;
  else
    cout << "ff is not in labels." << endl;
  return 0;
}

#include <stl.h>
#include 
#include 
int main ()
{
  vector <int> v1 (10);
  for (int i = 0; i < v1.size (); i++)
    v1[i] = rand () % 10;
  ostream_iterator<int> iter (cout, "
      ");
  copy (v1.begin (), v1.end (), iter);
  cout << endl;
  nth_element (v1.begin (),
               v1.begin () + v1.size () / 2,
               v1.end (),
               greater<int>());
  copy (v1.begin (), v1.end (), iter);
  cout << endl;
  return 0;
}

#include <stl.h>
#include 
int main ()
{
  vector <int> v1 (10);
  iota (v1.begin (), v1.end (), 0);
  vector <int> v2 (10);
  iota (v2.begin(), v2.end (), 7);
  ostream_iterator <int> iter (cout, "
      ");
  cout << "v1: ";
  copy (v1.begin (), v1.end (), iter);
  cout << "\nv2: ";
  copy (v2.begin (), v2.end (), iter);
  cout << endl;
  set_intersection (v1.begin (), v1.end (), v2.begin (), v2.end (), iter);
  cout << endl;
  return 0;
}

#include <stl.h>
#include 
int main ()
{
  vector <int> v1 (10);
  iota (v1.begin (), v1.end (), 0);
  vector <int> v2 (10);
  iota (v2.begin(), v2.end (), 7);
  ostream_iterator <int> iter (cout, "
      ");
  cout << "v1: ";
  copy (v1.begin (), v1.end (), iter);
  cout << "\nv2: ";
  copy (v2.begin (), v2.end (), iter);
  cout << endl;
  set_difference (v1.begin (), v1.end (), v2.begin (), v2.end (), iter);
  cout << endl;
  return 0;
}

#include <stl.h>
#include 
int mult (int a_, int b_)
{
  return a_ * b_;
}
int main ()
{
  vector <int> v (10);
  for (int i = 0; i < v.size (); i++)
    v[i] = i + 1;
  vector <int> rslt (v.size ());
  adjacent_difference (v.begin (), v.end (), rslt.begin (), mult);
  ostream_iterator<int> iter (cout, "
      ");
  copy (v.begin (), v.end (), iter);
  cout << endl;
  copy (rslt.begin (), rslt.end (), iter);
  cout << endl;
  return 0;
}

#include <stl.h>
#include 
int main ()
{
  vector <int> v1 (10);
  iota (v1.begin (), v1.end (), 0);
  ostream_iterator <int> iter (cout, "
      ");
  copy (v1.begin (), v1.end (), iter);
  cout << endl;
  for (int i = 0; i < v1.size (); i++)
  {
    rotate (v1.begin (), v1.begin () + i, v1.end ());
    ostream_iterator <int> iter (cout, "
        ");
    copy (v1.begin (), v1.end (), iter);
    cout << endl;
  }
  cout << endl;
  return 0;
}

#include <stl.h>
#include 
int main ()
{
  vector <int> v1 (10);
  iota (v1.begin (), v1.end (), 0);
  vector <int> v2 (10);
  iota (v2.begin(), v2.end (), 7);
  ostream_iterator <int> iter (cout, "
      ");
  cout << "v1: ";
  copy (v1.begin (), v1.end (), iter);
  cout << "\nv2: ";
  copy (v2.begin (), v2.end (), iter);
  cout << endl;
  set_union (v1.begin (), v1.end (), v2.begin (), v2.end (), iter);
  cout << endl;
  return 0;
}

#include 
#include <stl.h>
char* array1 [] = { "laurie", "jennifer", "leisa" };
char* array2 [] = { "amanda", "saskia", "carrie" };
int main ()
{
  deque<char*> names (array1, array1 + 3);
  deque<char*>::iterator i = names.begin () + 2;
  copy (array2, array2 + 3, insert_iterator<deque <char*> > (names, i));
  deque<char*>::iterator j;
  for (j = names.begin (); j != names.end (); j++)
    cout << *j << endl;
  return 0;
}

#include 
#include <math.h>
#include <stl.h>
struct square_root : public unary_function<double, double>
{
  square_root () {}
  double operator () (double x_) const { return sqrt (x_); }
};
int input [3] = { -1, -4, -16 };
int main ()
{ 
  int output [3];
  transform (input, input + 3, output, 
    compose1 (square_root (), negate<int> ()));
  for (int i = 0; i < 3; i++)
   cout << output[i] << endl;
  return 0;
}

#include <stl.h>
#include 
#include 
int main ()
{
  vector <int> v1 (10);
  for (int i = 0; i < v1.size (); i++)
    v1[i] = rand () % 10;
  ostream_iterator<int> iter (cout, "
      ");
  copy (v1.begin (), v1.end (), iter);
  cout << endl;
  partial_sort (v1.begin (),
                v1.begin () + v1.size () / 2,
                v1.end ());
  copy (v1.begin (), v1.end (), iter);
  cout << endl;
  return 0;
}

#include <stl.h>
#include 
bool values_squared (int a_, int b_)
{
  return (a_ * a_ == b_);
}
int main ()
{
  vector <int> v1 (10);
  vector <int> v2 (10);
  for (int i = 0; i < v1.size (); i++)
  {
    v1[i] = i;
    v2[i] = i * i;
  }
  if (equal (v1.begin (), v1.end (), v2.begin (), values_squared))
    cout << "v2[i] == v1[i] * v1[i]" << endl;
  else
    cout << "v2[i] != v1[i] * v1[i]" << endl;
  return 0;
}

#include <stl.h>
#include 
int main ()
{
  vector <int> v1(10);
  for (int i = 0; i < v1.size (); i++)
    v1[i] = (v1.size () - i - 1) % 5;
  ostream_iterator <int> iter (cout, "
      ");
  copy (v1.begin (), v1.end (), iter);
  cout << endl;
  inplace_merge (v1.begin (), v1.begin () + 5,
                 v1.end (),
                 greater<int>());
  copy (v1.begin (), v1.end (), iter);
  cout << endl;
  return 0;
}

#include <stl.h>
#include 
#include 
int main ()
{
  vector <int> v1 (10);
  for (int i = 0; i < v1.size (); i++)
    v1[i] = rand () % 10;
  ostream_iterator<int> iter (cout, "
      ");
  copy (v1.begin (), v1.end (), iter);
  cout << endl;
  nth_element (v1.begin (),
               v1.begin () + v1.size () / 2,
               v1.end ());
  copy (v1.begin (), v1.end (), iter);
  cout << endl;
  return 0;
}