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.

There is a good explanation here: http://en.cppreference.com/w/cpp/iterator/reverse_iterator. — juanchopanza, Oct 07 '14 at 06:11
thanks for the given link. It cleared the concept. Can you please give me the link which will show the clear implementation of operator++ function of reverse_itrator. — Swapnil, Oct 07 '14 at 09:10

score 3 · Answer 1 · answered Oct 07 '14 at 06:44

3

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

answered Oct 07 '14 at 06:44

Emilio Garavaglia

20,229
2
46
63

1

probably some explanation would make this response far better! – Olimpiu POP Oct 07 '14 at 07:16
If I add some explanation i will duplicate other answers. I just think that in this case a picture is better then hundredth of words. – Emilio Garavaglia Oct 07 '14 at 16:29

score 2 · Answer 2 · answered Oct 07 '14 at 06:08

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.

score 2 · Accepted Answer · answered Oct 07 '14 at 06:24

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

Close, but not necessarily:

they return iterators, not pointers....
end() returns an iterator that's notionally "past" the last valid index.

Internally the vector iterators 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);
            }

score 1 · Answer 4 · edited May 23 '17 at 12:13

1

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++.

edited May 23 '17 at 12:13

Community

1
1

answered Oct 07 '14 at 06:02

NPE

486,780
108
951
1,012

Marco A. · Answer 5 · 2014-10-07T06:15:54.103

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.

score 0 · Answer 6 · answered Oct 07 '14 at 06:27

0

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 )

answered Oct 07 '14 at 06:27

Laura Maftei

1,863
1
15
25

How Reverse Iterator in C++ works

6 Answers6