РУКОВОДСТВО ПО СТАНДАРТНОЙ БИБЛИОТЕКЕ ШАБЛОНОВ (STL)

 reverse_bidirectional_iterator(BidirectionalIterator х) : current(х) {}

 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 ‹class BidirectionalIterator, class T, class Reference, class Distance›

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 RandomAccessIterator, class T, class Reference = T&, class Distance = ptrdiff_t›

class reverse_iterator: public random_access_iterator‹T, Distance› {

 typedef reverse_iterator‹RandomAccessIterator, T, Reference, Distance› 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 ‹class RandomAccessIterator, class T, class Reference, class Distance›

inline bool operator==(const reverse_iterator‹RandomAccessIterator, T, Reference, Distance›& x, const reverse_iterator‹RandomAccessIterator, T, Reference, Distance›& y) {

 return x.current == y.current;

}

template ‹class RandomAccessIterator, class T, class Reference, class Distance›

inline bool operator‹(const reverse_iterator‹RandomAccessIterator, T, Reference, Distance›& x, const reverse_iterator‹RandomAccessIterator, T, Reference, Distance›& y) {

 return y.current ‹ x.current;

}