How Reverse Iterator in C++ works

Question

am beginner to c++ and i want to know how operator ++ moves iterator backward. As i know iterator.begin() and iterator.end() returns pointer to fist index and last index respectively.

vector<int>::iterator it = myvector.begin();

when we do it++ it will move to next index. this is clear to me but i am completely confused with reverse iterator.

vector<int>::reverse_iterator rit = myvector.rbegin();

when we do rit++ it will move to backward. I want know how this is implemented in case of reverse iterator. Is it operator overloading or something which i don't know. Please give me right way to understand these things.

please give more detail knowledge.

Answer 1

When you do it++ or rit++ they don't really mean "move forward or backward in the collection", they both mean "move to the next element you want to iterate over".

If you use begin() , you're saying "I want to iterate forwards", so it++ moves forwards.

If you use rbegin() , you're saying "I want to iterate backwards", so rit++ moves backwards.

Answer 2

As i know iterator.begin() and iterator.end() returns pointer to fist index and last index respectively.

Close, but not necessarily:

• they return iterator s, not pointers....

• end() returns an iterator that's notionally "past" the last valid index.

Internally the vector iterator s normally do store pointers though, and a ++ or -- on the iterator goes through a forwarding overloaded operator to perform a corresponding ++ or -- on the pointer.

For reverse iterators, the overloaded operator++ simply performs a -- on the pointer, and vice versa. For example, the Visual C++ library on my computer does this in class _Revranit , from which reverse_iterator is derived:

    _Myt&  operator++()
            {
            --current;
            return (*this);
            }

    _Myt  operator++(int)
            {
            _Myt _Tmp = *this;
            --current;
            return (_Tmp);
            }

Answer 3

_***************_
 ^begin ++--->  ^end
^rend <---++   ^rbegin

Answer 4

Yes, this is operator overloading. When you do rit++ , the compiler internally translates that do

rit.operator++(0);

Here, operator++ is a method of the reverse iterator class that knows how to move the iterator. The dummy integer argument is needed to differentiate between prefix and postfix operator++ .

Answer 5

Yes, there's a reverse_iterator::operator++ overload which advances "backwards" from the last element to one-before-the-beginning.

The behavior is equivalent to (the page on cppreference might contain another possible implementation)

    reverse_iterator operator++(int)
    {
      reverse_iterator __tmp(*this); 
      --current; // This is an internal iterator
      return __tmp;
    }

Notice that how this is exactly accomplished might vary from implementation to implementation. As far as you comply with the standard requirements, you have some degrees of freedom.

Answer 6

The relationship between a reverse iterator r and the iterator i it is constructed from is:

&*r == &*(i-1)

If end is the one-past-the-end element in a sequence, then the first element in the reversed sequence points to *( end – 1 )