迭代器的后继者不一定是正则函数：怎么可能？

Question

在Elements of Programming一书的第 91 页中，Stepanov 和 McJones 说 Iterator 的概念需要一个 successor 函数，但这不一定是常规的，因为

...i = j 并不意味着successor(i) = successor(j)...

（见page online）

我理解相反的successor(i) = successor(j) 并不暗示i=j（例如在两个以空结尾的列表中）并且可能没有为某些输入定义successor 函数。但我不明白i = j 怎么可能导致successor(i) != successor(j)。

他们指的是什么情况？也许是一些随机（如偶然）跳跃的迭代器？或者一些具有隐藏状态的迭代器，在指向同一个元素（并且在这个意义上比较相等）之后，与另一个迭代器“跳跃”不同。

他们立即跳转到需要常规 successor 函数的改进（ForwardIterator），所以我不清楚。

---

最初我认为输入迭代器可以具有此属性。但是，我仍然很难看出这是否构成反例：（在 STL 的某个实现中）。

#include <iostream>
#include <sstream>
#include <iterator>
#include <numeric>
#include <cassert>
using std::cout; using std::endl;
int main(){
    std::istream_iterator<int> it1(std::cin); // wait for one input
    std::istream_iterator<int> it2 = it1;
    assert(it1 == it2);
    cout << "*it1 = " << *it1 << endl;
    cout << "*it2 = " << *it2 << endl;
    cout << "now sucessor" << endl;
    ++it1; // wait for one input
    ++it2; // wait for another input
    assert(it1 == it2); // inputs still compare equal !
    cout << "*it1 = " << *it1 << endl;
    cout << "*it2 = " << *it2 << endl;
    assert(it1 == it2); // also here ! and yet they point to different values...
    assert(*it1 == *it2); // assert fails! 
}

（使用 GCC 6.1 编译）

Answer 1

考虑将类型iter定义为：

struct iter { unsigned value; };

inline bool operator==(iter const& x, iter const& y) {
  return x.value == y.value;
}
inline bool operator!=(iter const& x, iter const& y) {
  return !(x == y);
}
auto source(iter const& x) {
  return x.value;
}
iter successor(iter const&) {
  std::random_device engine{};
  std::uniform_int_distribution<unsigned> dist{};
  return {dist(engine)};
}

IIRC，iter 满足 EoP 的 Iterator 概念的要求：它是 Regular，source 是常规函数，successor 尤其是非常规函数。 给定iter 类型的两个对象i 和j，使得i == j，极有可能是successor(i) != successor(j)。

Answer 2

一个例子可以是一个successor函数，它消耗一个数据流（正如他们在书中提到的那样）。
当您阅读了 i-th 元素后，理论上您只能为它调用一次 successor 函数。如果您尝试调用它两次，结果会有所不同。
简单想象successor(i) 从流中读取下一个元素，即 i-th+1 元素。它实际上意味着消耗它并且它不再可用。如果您再次调用 successor(i)，您将从流中获取 i-th+2 元素。
因此，如果输入相同 (i = j)，则无法保证输出相同 (successor(i) = successor(j))。