The class tt(Vector) as yet has not reverse iterator. With the reverse
iterator we have to make sure that the increment operator takes us to the
previous element. Therefore, the tt(operator++) must be redefined.

However, since the tt(++) operator may be used as a prefix or postfix
operator, a simple redefinition is not enough. The postfix-version of the
operator needs a dummy tt(int) parameter, as discussed in section
ref(OVERLOADINCR).

Furthermore, a reverse iterator may occur in different classes, each based on
the existence of an iterator type. Therefore, a class template is indicated
here. The iterator class that was introduced as the class tt(Vector) in
section ref(OVERLOADINCR) serves as a basis for the construction of the
class template tt(reverse_iterator).

A reverse iterator has the following characteristics:
    itemization(
        it() The increment operator resets the pointer to the em(previous)
element.
        it() The decrement operator advances the pointer to the em(next)
element.
    )
    This behavior requires overloading the increment and decrement
operators. Furthermore, the reverse iterator is initialized by a pointer into
the datastructure for which the reverse iterator is needed. Just like the
member functions tt(begin()) and tt(end()) there exist member functions
tt(rbegin()) and tt(rend()). Now there are two possibilities: first, these
functions may set tt(rbegin()) to the very last element, and tt(rend()) to the
element before the very first element, or tt(rbegin()) returns tt(end()) and
tt(rend()) returns tt(begin()), while the tt(reverse_iterator) class takes
care of the required resetting of the pointer when an element is returned. In
line with the current implementation of the tt(reverse_iterator) class the
latter approach is illustrated here.

The class template tt(reverse_iterator) requires pre- and postfix
increment and decrement operators. A tt(reverse_iterator) object is
constructed using an tt(Iterator) object.

    The position in the data where the tt(reverse_iterator) object points
to is stored interally in the tt(reverse_iterator) object in an tt(Iterator)
object.

    Furthermore, the class needs member functions to access the data pointed to
by the reverse iterator. This is done by the dereference operator
tt(operator*()), which uses a temporary tt(Iterator) to refer to the previous
element.

    The reverse iterator class can be constructed as follows:
        verbinclude(-a vector/reverseiterator.h)
