Adaptors

Adaptors are template classes that provide an existing class with a new interface. Adaptors can be used to create new interfaces for containers or iterators.

The STL provides container adaptors, some which change the behavior of an underlying container, some which allow a non-STL data structure to be used in STL algorithms.

Container Adaptors

Often it is desirable to create a specialized container from an existing, more general container. The operations of the new container are implemented using the underlying operations of the existing containers. Container adaptors are used to create a new container by mapping the interface of an existing container to that of the new container. This allows new containers to be created without much additional effort, since most of the functionality is already provided by the existing container.

The STL provides three container adaptors:

·         stack<Container>;

·          queue<Container>;

·         deque<Container>.

The following program demonstrates the use of a stack that has been implemented as a vector:

#include <vector.h>
#include <stack.h>
void main()  {
   stack <vector<int> > st;
   for (int i=0; i < 10; i++)
      st.push (i);
   while ( !st.empty() ) {
      cout << st.top() << " ";
      st.pop();
   }
   cout << endl;
}

iterator adaptors

Adaptors can also be used to extend the functionality of an existing iterator. The STL provides three iterator adaptors:

• Reverse iterators. Random access iterators and bi-directional iterators can be traversed forwards and backwards. By applying the reverse_iterator adaptor to either a random access iterator or a bi-directional iterator an iterator is obtained that will traverse the same container in the reverse direction.
• Insert iterators. Iterators behave a lot like pointers; if you assign a new value to a container through it's iterator, you will overwrite any value that is already at the location specified by the iterator. Sometimes, it is desirable to be able to insert a new element at that location in the container.

The STL provides three different insert iterators that instead of overwriting the value at that location, actually insert a value there. Each type of adaptor performs the insertion into the container in a different place.

• back_insert_iterators add new elements to the end of the container. Because the algorithm uses the back_insert function to do the insertions it can only be used with vectors, lists, and deques.
• front_insert_iterators add new elements to the front of a container. Because push_front is used for insertions, it can only be used on lists, and deques.
• insert_iterators add new elements to the container at the location specified when the iterator is constructed. This iterator can be used to insert new elements anywhere within a container, not just at the front or the end. Because it uses insert to add the elements, it can be used with any of the STL containers.
• Raw storage iterators. Raw storage iterators allow algorithms to use raw, uninitialized memory during their execution. The raw_storage_iterator is used by several internal algorithms for partitioning and merging elements in a container.