Next : Insert iterators, Previous : Iterator adaptors, Top : Table of  Contents

Reverse iterators

reverse_bidirectional_iterator	Bidirectional Iterator
reverse_iterator	Random Access Iterator

Bidirectional and random access iterators have corresponding reverse iterator adaptors that iterate through the data structure in the opposite direction. They have the same signatures as the corresponding iterators. The fundamental relation between a reverse iterator and its corresponding iterator i is established by the identity

&*(reverse_iterator(i)) == &*(i - 1).

reverse_bidirectional_iterator ()	Constructor on reverse_bidirectional_iterator
reverse_bidirectional_iterator (BidirectionalIterator x)	Constructor on reverse_bidirectional_iterator
*	Operator on reverse_bidirectional_iterator
++	Operator on reverse_bidirectional_iterator
--	Operator on reverse_bidirectional_iterator
==	Operator on reverse_bidirectional_iterator

reverse_iterator ()	Constructor on reverse_iterator
reverse_iterator (RandomAccessIterator x)	Constructor on reverse_iterator
*	Operator on reverse_iterator
++	Operator on reverse_iterator
--	Operator on reverse_iterator
+	Operator on reverse_iterator
+=	Operator on reverse_iterator
-	Operator on reverse_iterator
-=	Operator on reverse_iterator
[]	Operator on reverse_iterator
==	Operator on reverse_iterator
<	Operator on reverse_iterator

template 

class reverse_bidirectional_iterator
: public bidirectional_iterator {
    typedef reverse_bidirectional_iterator self;
    friend bool operator==(const self& x, const self& y);

protected:
    BidirectionalIterator current;

public:
    reverse_bidirectional_iterator() {}
    reverse_bidirectional_iterator(BidirectionalIterator x) : current(x) {}
    BidirectionalIterator base() { return current; }
    Reference operator*() const {
        BidirectionalIterator tmp = current;
        return *--tmp;
    }
    self& operator++() { --current; return *this; }
    self operator++(int) { self tmp = *this; --current; return tmp; }
    self& operator--() { ++current; return *this; }
    self operator--(int) { self tmp = *this; ++current; return tmp; }
};

template 

inline bool operator==(const reverse_bidirectional_iterator<
                             BidirectionalIterator, T,
                             Reference, Distance>& x,
                       const reverse_bidirectional_iterator<
                             BidirectionalIterator, T,
                             Reference, Distance>& y) {
    return x.current == y.current;
}

template 

class reverse_iterator : public random_access_iterator {
    typedef reverse_iterator
        self;
    friend bool operator==(const self& x, const self& y);
    friend bool operator<(const self& x, const self& y);
    friend Distance operator-(const self& x, const self& y);
    friend self operator+(Distance n, const self& x);

protected:
    RandomAccessIterator current;

public:
    reverse_iterator() {}
    reverse_iterator(RandomAccessIterator x) : current(x) {}
    RandomAccessIterator base() { return current; }
    Reference operator*() const {
        RandomAccessIterator tmp = current;
        return *--tmp;
    }
    self& operator++() { --current; return *this; }
    self operator++(int) { self tmp = *this; --current; return tmp; }
    self& operator--() { ++current; return *this; }
    self operator--(int) { self tmp = *this; ++current; return tmp; }
    self operator+(Distance n) const { return self(current - n); }
    self& operator+=(Distance n) { current -= n; return *this; }
    self operator-(Distance n) const { return self(current + n); }
    self& operator-=(Distance n) { current += n; return *this; }
    Reference operator[](Distance n) { return *(*this + n); }
};

template 

inline bool operator==(const reverse_iterator& x,
                       const reverse_iterator& y) {
    return x.current == y.current;
}

template 

inline bool operator<(const reverse_iterator& x,
                      const reverse_iterator& y) {
    return y.current < x.current;
}

template 

inline Distance operator-(const reverse_iterator& x,
                          const reverse_iterator& y) {
    return y.current - x.current;
}

template 

inline reverse_iterator
    operator+(Distance n,
              const reverse_iterator& x) {
        return reverse_iterator(x.current - n);
}