C++ 是否有一个迭代器的例子，它不会'；t使用ptrdiff作为其差异类型？

我发现，

iterator\u traits

总是定义一个

差异类型

：

---

我只是想知道为什么，不是每种类型都是

ptrdiff\u t

？是否有一个迭代器示例不使用

ptrdiff\u t

？如果不是的话，

difference\u type

为什么没有从

iterators\u traits

和

ptrdiff\u t

中删除呢？

一个基本的输出迭代器，作为一个例子，可能根本不需要difference类型

---

因为它是一个“火和遗忘”类型的迭代器，所以在两个迭代器之间获得差异通常没有多大意义。仅仅是在一份副本上书写的行为就可能使所有其他副本失效。因此，它不需要定义一个差异类型，也不应该人为地强制这样做（或者强制类型）。

我编写了一个rope类型，它可以处理大于潜在内存的备份存储（也就是说，它可以处理64位序列，甚至是32位代码）。因此，无论是以32位还是64位模式编译，我都必须使用64位大小和差异类型。

理论上，任何迭代器的差异都不能在

std:：ptrdiff\u t

中表示。例如，考虑下面的玩具迭代器，它给定一个方向，导航2D矩阵：

template<typename T>
struct vec2d {T x; T y;};

template<typename T, typename C>
class cartesian_iterator {
public:
    using value_type = T;
    // because the difference between 2d vectors is an actual 2d vector,
    // we can't use std::ptrdiff_t
    using difference_type = vec2d<int>;

    cartesian_iterator(C* container, vec2d<size_t> position, difference_type increment = difference_type{1,1})
        :    container{container}, position{position}, increment{increment}
    {}

    cartesian_iterator& operator++() {position.x += increment.x; position.y += increment.y; return *this;}
    bool operator==(const cartesian_iterator& rhs) {return position.x == rhs.position.x && position.y == rhs.position.y;}
    bool operator!=(const cartesian_iterator& rhs) {return position.x != rhs.position.x || position.y != rhs.position.y;}
    T& operator*() {
        return (*container)[position.x][position.y];
    }

    // difference could be implemented like this
    difference_type operator-(const cartesian_iterator& rhs) {
        return {
            static_cast<int>(position.x) - static_cast<int>(rhs.position.x),
            static_cast<int>(position.y) - static_cast<int>(rhs.position.y),
        };
    }
private:
    C* container;
    vec2d<size_t> position;
    difference_type increment{1,1};
};

模板
结构向量2D{TX；TY；}；
模板
类笛卡尔迭代器{
公众：
使用值_type=T；
//因为2d向量之间的差异是一个实际的2d向量，
//我们不能使用std:：ptrdiff\t
使用差分_type=vec2d；
笛卡尔迭代器（C*容器，vec2d位置，差分类型增量=差分类型{1,1}）
：容器{container}，位置{position}，增量{increment}
{}
笛卡尔迭代器和运算符++（）{position.x+=increment.x；position.y+=increment.y；返回*this；}
布尔运算符==（常量笛卡尔迭代器&rhs）{return position.x==rhs.position.x&&position.y==rhs.position.y；}
布尔运算符！=（常量笛卡尔迭代器&rhs）{return position.x！=rhs.position.x | | position.y！=rhs.position.y；}
T&运算符*（）{
返回（*容器）[position.x][position.y]；
}
//差异可以这样实现
差分类型运算符-（常量笛卡尔迭代器和rhs）{
返回{
静态施法（位置x）-静态施法（右侧位置x），
静态施法（位置y）-静态施法（右侧位置y），
};
}
私人：
C*集装箱；
向量2D位置；
差分_型增量{1,1}；
};

用法：

// outputs 159
int main() {
    using std::array;
    array<array<int, 3>, 3> a {
        1,2,3,
        4,5,6,
        7,8,9
    };
    cartesian_iterator<int, array<array<int, 3>, 3>> it{&a, {0, 0}};
    while (it != decltype(it){&a, {3,3}}) {
        std::cout << *it;
        ++it;
    }
}

//输出159
int main（）{
使用std：：数组；
数组a{
1,2,3,
4,5,6,
7,8,9
};
笛卡尔迭代器it{&a，{0，0}；
while（it！=decltype（it）{&a，{3,3}}）{
std:：cout不仅限于输出迭代器。这同样适用于任何不是前向迭代器的迭代器。如果标准库中有非前向输入迭代器，我将不使用它，但可以想象一个UDP迭代器，它在一次传递中迭代传入的数据报。