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

Question

C++20 对std::contiguous_iterator_tag. 一些 STL 算法（例如std::copy）可以在连续迭代器上表现得更好。但是，我不清楚程序员应该如何访问这个新功能。

为了论证起见，让我们假设我们有一个完全符合 C++20 的库实现。我想编写最简单的连续迭代器。

这是我的第一次尝试。

#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除了库需要的一个函数之外，我没有放入任何东西。这是我的第二次尝试：

#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!

这是我应该做的吗？感觉非常hacky。（需要明确的是：我的第一次失败尝试也感觉非常糟糕。）

我错过了一些更简单的方法吗？

特别是，是否有任何方法MyIterator可以保证它是连续的，只使用成员和朋友以及可以在类的主体中定义的东西？就像， ifMyIterator是在某个深度嵌套的命名空间中定义的，我不想一直突破到顶级命名空间以打开namespace std.

---

编辑补充：格伦·费尔南德斯告诉我，那里是一个更简单的方法-我应该只需要加一个element_type类型定义，这个样子！（而且我可以iterator_traits在 C++20 中删除'big 5 typedef 中的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!

---

另外，我已经看到了一些关于使用成员 typedefiterator_concept而不是iterator_category. 为什么我可能想要提供MyIterator::iterator_concept？（我不是在这里要求完整的历史解释；只是一个简单的最佳实践指南“不要忘记iterator_concept”或“是的，因为它对 X 有帮助”会很好。）

Answer 1

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

\n

\n
• MyIterator::value_type应该是被指点者的cv-unqualified类型，这样有人就可以写value_type x; x = *it;
\n
• MyIterator::element_type应该是被指点者的简历限定类型，这样有人就可以写element_type *ptr = std::to_address(it);
\n

\n

因此，对于 const 迭代器来说，element_type它不仅仅是value_type\xe2\x80\x94 的同义词，它还是const value_type!的同义词。如果你不这样做，标准库内的东西就会爆炸。

\n

这是 Godbolt 概念验证。（这不是一个完整的生态系统，因为您确实希望MyIterator隐式转换为MyConstIterator，并且可能使用模板来消除一些重复。我在这里有一篇关于该主题的漫漫博客文章。）

\n

#include <iterator>\n\nclass MyIterator {\n    int *p_;\npublic:\n    using value_type = int;\n    using element_type = int;\n    using iterator_category = std::contiguous_iterator_tag;\n    int *operator->() const;\n    int& operator*() const;\n    int& operator[](int) const;\n    MyIterator& operator++();\n    MyIterator operator++(int);\n    MyIterator& operator--();\n    MyIterator operator--(int);\n    MyIterator& operator+=(int);\n    MyIterator& operator-=(int);\n    friend auto operator<=>(MyIterator, MyIterator) = default;\n    friend int operator-(MyIterator, MyIterator);\n    friend MyIterator operator+(MyIterator, int);\n    friend MyIterator operator-(MyIterator, int);\n    friend MyIterator operator+(int, MyIterator);\n};\n\nstatic_assert(std::contiguous_iterator<MyIterator>);  // OK!\n\nclass MyConstIterator {\n    const int *p_;\npublic:\n    using value_type = int;\n    using element_type = const int;\n    using iterator_category = std::contiguous_iterator_tag;\n    const int *operator->() const;\n    const int& operator*() const;\n    const int& operator[](int) const;\n    MyConstIterator& operator++();\n    MyConstIterator operator++(int);\n    MyConstIterator& operator--();\n    MyConstIterator operator--(int);\n    MyConstIterator& operator+=(int);\n    MyConstIterator& operator-=(int);\n    friend auto operator<=>(MyConstIterator, MyConstIterator) = default;\n    friend int operator-(MyConstIterator, MyConstIterator);\n    friend MyConstIterator operator+(MyConstIterator, int);\n    friend MyConstIterator operator-(MyConstIterator, int);\n    friend MyConstIterator operator+(int, MyConstIterator);\n};\n\nstatic_assert(std::contiguous_iterator<MyConstIterator>);  // OK!\n

\n

Answer 2

有两种方式支持std::to_address。一是：

namespace std {

template<>
struct pointer_traits<I> {
    static X* to_address(const I& i) {
        // ...
    }
};

}

请注意static以上内容。

正如格伦向您指出的那样，第二种方法是简单地定义I::operator->并确保主要模板std::pointer_traits<I>是有效的。这仅要求std::pointer_traits<I>::element_type有效。

Nicol Bolas 的答案是不正确的，因为这不是您自定义std::to_address用户定义类型的方式。从 C++20 开始（由于 P0551），禁止在std未明确允许的命名空间中专门化函数模板。

你不被允许专攻std::to_address。不过您可以提供std::pointer_traits<I>::to_address，并且std::to_address如果存在的话会调用它。