Thinking In C++. Volume 2: Practical Programming

  cout << title << ':' << endl;

  if(c.empty()) {

    cout << "(empty)" << endl;

    return;

  }

  typename Container::iterator it;

  for(it = c.begin(); it != c.end(); it++)

    cout << *it << " ";

  cout << endl;

  cout << "size() " << c.size()

    << " max_size() "<< c.max_size()

    << " front() " << c.front()

    << " back() " << c.back() << endl;

}

template

void basicOps(char* s) {

  cout << "------- " << s << " -------" << endl;

  typedef ContainerOfInt Ci;

  Ci c;

  print(c, "c after default constructor");

  Ci c2(10, 1); // 10 elements, values all 1

  print(c2, "c2 after constructor(10,1)");

  int ia[] = { 1, 3, 5, 7, 9 };

  const int iasz = sizeof(ia)/sizeof(*ia);

  // Initialize with begin & end iterators:

  Ci c3(ia, ia + iasz);

  print(c3, "c3 after constructor(iter,iter)");

  Ci c4(c2); // Copy-constructor

  print(c4, "c4 after copy-constructor(c2)");

  c = c2; // Assignment operator

  print(c, "c after operator=c2");

  c.assign(10, 2); // 10 elements, values all 2

  print(c, "c after assign(10, 2)");

  // Assign with begin & end iterators:

  c.assign(ia, ia + iasz);

  print(c, "c after assign(iter, iter)");

  cout << "c using reverse iterators:" << endl;

  typename Ci::reverse_iterator rit = c.rbegin();

  while(rit != c.rend())

    cout << *rit++ << " ";

  cout << endl;

  c.resize(4);

  print(c, "c after resize(4)");

  c.push_back(47);

  print(c, "c after push_back(47)");

  c.pop_back();

  print(c, "c after pop_back()");

  typename Ci::iterator it = c.begin();

  it++; it++;

  c.insert(it, 74);

  print(c, "c after insert(it, 74)");

  it = c.begin();

  it++;

  c.insert(it, 3, 96);

  print(c, "c after insert(it, 3, 96)");

  it = c.begin();

  it++;

  c.insert(it, c3.begin(), c3.end());

  print(c, "c after insert("

    "it, c3.begin(), c3.end())");

  it = c.begin();

  it++;

  c.erase(it);

  print(c, "c after erase(it)");

  typename Ci::iterator it2 = it = c.begin();

  it++;

  it2++; it2++; it2++; it2++; it2++;

  c.erase(it, it2);

  print(c, "c after erase(it, it2)");

  c.swap(c2);

  print(c, "c after swap(c2)");

  c.clear();

  print(c, "c after clear()");

}

int main() {

  basicOps >("vector");

  basicOps >("deque");

  basicOps >("list");

} ///:~

The first function template, print( ), demonstrates the basic information you can get from any sequence container: whether it’s empty, its current size, the size of the largest possible container, the element at the beginning, and the element at the end. You can also see that every container has begin( ) and end( ) member functions that return iterators.

The basicOps( ) function tests everything else (and in turn calls print( )), including a variety of constructors: default, copy-constructor, quantity and initial value, and beginning and ending iterators. There are an assignment operator= and two kinds of assign( ) member functions. One takes a quantity and an initial value, and the other takes a beginning and ending iterator.

All the basic sequence containers are reversible containers, as shown by the use of the rbegin( ) and rend( ) member functions. A sequence container can be resized, and the entire contents of the container can be removed with clear( ). When you call resize( ) to expand a sequence, the new elements use the default constructor of the type of element in the sequence, or if they are built-in types, they are zero-initialized^.

Using an iterator to indicate where you want to start inserting into any sequence container, you can insert( ) a single element, a number of elements that all have the same value, and a group of elements from another container using the beginning and ending iterators of that group^.

To erase( ) a single element from the middle, use an iterator; to erase( ) a range of elements, use a pair of iterators. Notice that since a list supports only bidirectional iterators, all the iterator motion must be performed with increments and decrements. (If the containers were limited to vector and deque, which produce random-access iterators, operator+ and operator- could have been used to move the iterators in big jumps.)

Although both list and deque support push_front( ) and pop_front( ), vector does not, so the only member functions that work with all three are push_back( ) and pop_back( ).