迭代器的std :: distance差于RandomAccessIterator

Question

I recently reviewed not long ago implemented algorithm and found, that it can be improved to be able to operate on not just only RandomAccessIterator input range, but even on ForwardIterator one ( multipass guarantee is still the requirement).

I decide to simply downgrade the requirement by modifying all the places in the code, that currently uses simple difference between iterators, in a way to use std::distance instead. The std::distance algorithm described here . Due to very nature of std::distance algorithm the modifications was not just a search and replace one, namely:

• For ordered containers internally used in the algorithm I replaced all occurences of operator < or std::less< iterator > / std::less<> with:

auto const less = [ibeg = std::cbegin(input)] (iterator const & l, iterator const & r)
                   {
                       return std::distance(ibeg, l) < std::distance(ibeg, r);
                   };

Say, std::set< iterator > x; modified to be std::set< iterator, decltype(less) > x{less}; .

• For unordered containers internally used in the algorithm ( value_type is iterator ) I use std::hash< std::intptr_t > h; hash function for simple difference h(lhs - rhs) (actually xor combination of hash values, but it not matters here) for some fixed iterator lhs and a number of varying iterator rhs . It modified to be h(std::distance(lhs, rhs)) .

The former point is correct, but the latter is evidently no. Due to rhs can be unrecheable from lhs just only by means of simple incrementation and there is no way to know what to do a priori: to increment lhs to reach rhs or to increment rhs to reach lhs .

But above hash still works. It is strange... because sometimes, when lhs > rhs (in some sense), there should be access violation (sometimes). Say, if:

std::list< int > input{1, 2, 3, 4};
auto a = std::begin(input), b = std::next(lhs, 2);

then increments, contained into std::distance(b, a) , should never stop and eventually reaches boundary of not yet allocated memory page. But AV never happens in my program. std::distance always return non-negative number.

Is it undefined behaviour or is it permittable to apply std::distance for any pair of ForwardIterator-s? The -stdlib= is libc++ .

Answer 1

[...] is it permittable to apply std::distance for any pair of ForwardIterator -s?

If you want to stick to the standard, then clearly no, it's not permitted :

 template <class InputIterator> typename iterator_traits<InputIterator>::difference_type distance( InputIterator first, InputIterator last); 

[...] Requires: If InputIterator meets the requirements of random access iterator, last shall be reachable from first or first shall be reachable from last ; otherwise, last shall be reachable from first .

[N4431 §24.4.4/5]

The reason is that for forward iterators the function is repeatedly applying operator++ to get from first to last :

Since only random access iterators provide + and -operators, the library provides two function templates advance and distance . These function templates use + and - for random access iterators (and are, therefore, constant time for them); for input, forward and bidirectional iterators they use ++ to provide linear time implementations.

[N4431 §24.4.4/1]

Answer 2

From the documentaton you linked "If InputIt is not RandomAccessIterator , the behavior is undefined if last is not reachable from first by (possibly repeatedly) incrementing first ".

Undefined behaviour does not mean an access violation; it means anything at all, including returning some positive number.