This page is a snapshot from the LWG issues list, see the Library Active Issues List for more information and the meaning of CD1 status.

### 280. Comparison of reverse_iterator to const reverse_iterator

Section: 25.5.1 [reverse.iterators] Status: CD1 Submitter: Steve Cleary Opened: 2000-11-27 Last modified: 2020-03-29

Priority: Not Prioritized

View all other issues in [reverse.iterators].

View all issues with CD1 status.

Discussion:

This came from an email from Steve Cleary to Fergus in reference to issue 179. The library working group briefly discussed this in Toronto and believed it should be a separate issue. There was also some reservations about whether this was a worthwhile problem to fix.

Steve said: "Fixing `reverse_iterator`. `std::reverse_iterator` can (and should) be changed to preserve these additional requirements." He also said in email that it can be done without breaking user's code: "If you take a look at my suggested solution, reverse_iterator doesn't have to take two parameters; there is no danger of breaking existing code, except someone taking the address of one of the reverse_iterator global operator functions, and I have to doubt if anyone has ever done that. . . But, just in case they have, you can leave the old global functions in as well -- they won't interfere with the two-template-argument functions. With that, I don't see how any user code could break."

Proposed resolution:

Section: 25.5.1.2 [reverse.iterator] add/change the following declarations:

      A) Add a templated assignment operator, after the same manner
            as the templated copy constructor, i.e.:

      template < class U >
      reverse_iterator < Iterator >& operator=(const reverse_iterator< U >& u);

      B) Make all global functions (except the operator+) have
      two template parameters instead of one, that is, for
      operator ==, !=, <, >, <=, >=, - replace:

           template < class Iterator >
           typename reverse_iterator< Iterator >::difference_type operator-(
                     const reverse_iterator< Iterator >& x,
                     const reverse_iterator< Iterator >& y);

      with:

          template < class Iterator1, class Iterator2 >
          typename reverse_iterator < Iterator1 >::difference_type operator-(
                     const reverse_iterator < Iterator1 > & x,
                     const reverse_iterator < Iterator2 > & y);

Also make the addition/changes for these signatures in [reverse.iter.ops].

[ Copenhagen: The LWG is concerned that the proposed resolution introduces new overloads. Experience shows that introducing overloads is always risky, and that it would be inappropriate to make this change without implementation experience. It may be desirable to provide this feature in a different way. ]

[ Lillehammer: We now have implementation experience, and agree that this solution is safe and correct. ]

[2020-03-29; Jonathan Wakely comments]

The issue title is misleading, it is not about comparing to `const`-qualified `reverse_iterator`s, but comparing to `reverse_iterator<const-iterator>`.