在C++20中，如何编写连续的迭代器？

2022-08-15 00:00:00 iterator c++ stl c++20 contiguous

C++20显式支持std::contiguous_iterator_tag。一些STL算法(例如std::copy)可以在连续迭代器上执行得更好。但是，我不清楚程序员应该如何访问此新功能。

为了便于讨论，我们假设我们有一个完全符合C++20的库实现。我想编写尽可能最简单的连续迭代器。

Here's my first attempt.

#include <iterator>

class MyIterator {
    int *p_;
public:
    using value_type = int;
    using reference = int&;
    using pointer = int*;
    using difference_type = int;
    using iterator_category = std::contiguous_iterator_tag;
    int *operator->() const;
    int& operator*() const;
    int& operator[](int) const;
    MyIterator& operator++();
    MyIterator operator++(int);
    MyIterator& operator--();
    MyIterator operator--(int);
    MyIterator& operator+=(int);
    MyIterator& operator-=(int);
    friend auto operator<=>(MyIterator, MyIterator) = default;
    friend int operator-(MyIterator, MyIterator);
    friend MyIterator operator+(MyIterator, int);
    friend MyIterator operator-(MyIterator, int);
    friend MyIterator operator+(int, MyIterator);
};

namespace std {
    int *to_address(MyIterator it) {
        return it.operator->();
    }
}

static_assert(std::contiguous_iterator<MyIterator>);  // FAILS

这在GCC/libstdc++和msvc/stl上都失败；但它应该失败吗？

对于我的下一次尝试，我专门化了pointer_traits<MyIterator>。MyIterator实际上不是一个指针，所以我没有在pointer_traits中放入任何东西，除了库需要的一个函数。This is my second attempt：

#include <iterator>

class MyIterator {
    ~~~
};

template<>
struct std::pointer_traits<MyIterator> {
    int *to_address(MyIterator it) {
        return it.operator->();
    }
};

static_assert(std::contiguous_iterator<MyIterator>);  // OK!

这是我应该做的吗？感觉非常刺耳。(需要说明的是：我的第一次尝试失败也感觉非常麻烦。)

我是不是错过了一些更简单的方式？

具体地说，MyIterator本身有没有办法保证它是连续的，只使用可以在类主体中定义的成员和朋友以及其他东西？比如，如果MyIterator是在某个深度嵌套的命名空间中定义的，我不想为了打开namespace std而一直中断到顶层命名空间。

编辑后添加：Glen Fernandes告诉我有一种更简单的方法--我只需添加一个element_type类型定义，like this!(并且我可以在C++20中删除iterator_traits‘5个较大的类型定义中的3个。)这看起来好多了！

#include <iterator>

class MyIterator {
    int *p_;
public:
    using value_type = int;
    using element_type = int;
    using iterator_category = std::contiguous_iterator_tag;
    int *operator->() const;
    int& operator*() const;
    int& operator[](int) const;
    MyIterator& operator++();
    MyIterator operator++(int);
    MyIterator& operator--();
    MyIterator operator--(int);
    MyIterator& operator+=(int);
    MyIterator& operator-=(int);
    friend auto operator<=>(MyIterator, MyIterator) = default;
    friend int operator-(MyIterator, MyIterator);
    friend MyIterator operator+(MyIterator, int);
    friend MyIterator operator-(MyIterator, int);
    friend MyIterator operator+(int, MyIterator);
};

static_assert(std::contiguous_iterator<MyIterator>);  // OK!

此外，我还看到了一些关于使用成员tyecifiterator_concept而不是iterator_category的内容。我为什么要提供MyIterator::iterator_concept？(我在这里并不要求完整的历史解释；我只是要求一个简单的最佳实践指导方针，忘掉iterator_concept或是的，提供它，因为它有助于X&q；将会很好。)

解决方案

我问题中的最后一个版本似乎是最正确的。只有一个细微之处需要注意：

MyIterator::value_type应该是指针对象的cv-unfined类型，这样别人就可以写value_type x; x = *it;
MyIterator::element_type应该是指针对象的cv限定的类型，这样别人就可以写element_type *ptr = std::to_address(it);

因此，对于常量迭代器，element_type不仅仅是value_type的同义词--它还是const value_type的同义词！如果您不这样做，标准库内部的东西将会爆炸。

Here's a Godbolt proof-of-concept.(它不是一个完整的生态系统，因为您实际上希望MyIterator隐式转换为MyConstIterator，并且可能使用模板来消除一些重复。我有一篇关于这个主题的漫无边际的博客文章here。)

#include <iterator>

class MyIterator {
    int *p_;
public:
    using value_type = int;
    using element_type = int;
    using iterator_category = std::contiguous_iterator_tag;
    int *operator->() const;
    int& operator*() const;
    int& operator[](int) const;
    MyIterator& operator++();
    MyIterator operator++(int);
    MyIterator& operator--();
    MyIterator operator--(int);
    MyIterator& operator+=(int);
    MyIterator& operator-=(int);
    friend auto operator<=>(MyIterator, MyIterator) = default;
    friend int operator-(MyIterator, MyIterator);
    friend MyIterator operator+(MyIterator, int);
    friend MyIterator operator-(MyIterator, int);
    friend MyIterator operator+(int, MyIterator);
};

static_assert(std::contiguous_iterator<MyIterator>);  // OK!

class MyConstIterator {
    const int *p_;
public:
    using value_type = int;
    using element_type = const int;
    using iterator_category = std::contiguous_iterator_tag;
    const int *operator->() const;
    const int& operator*() const;
    const int& operator[](int) const;
    MyConstIterator& operator++();
    MyConstIterator operator++(int);
    MyConstIterator& operator--();
    MyConstIterator operator--(int);
    MyConstIterator& operator+=(int);
    MyConstIterator& operator-=(int);
    friend auto operator<=>(MyConstIterator, MyConstIterator) = default;
    friend int operator-(MyConstIterator, MyConstIterator);
    friend MyConstIterator operator+(MyConstIterator, int);
    friend MyConstIterator operator-(MyConstIterator, int);
    friend MyConstIterator operator+(int, MyConstIterator);
};

static_assert(std::contiguous_iterator<MyConstIterator>);  // OK!

相关文章