在 C++23 中编译迭代器时出现“原子约束依赖于自身”错误

Question

我正在尝试制作一个迭代器，它主要逐个字符地传递字符串视图，但有一些特殊情况，我尝试的是以下内容：

// iter.hpp
#include <string_view>

typedef std::basic_string_view<char> UStringView;

class symbol_iter
{
private:
  UStringView str;
  UStringView::size_type sloc = 0;
  UStringView::size_type eloc = 0;
public:
  symbol_iter(UStringView s);
  symbol_iter(const symbol_iter& other);
  ~symbol_iter();
  UStringView operator*();
  symbol_iter& operator++();
  bool operator!=(const symbol_iter& other) const;
  bool operator==(const symbol_iter& other) const;
  symbol_iter begin();
  symbol_iter end();
};

symbol_iter::symbol_iter(UStringView s) : str(s)
{
  ++*this;
}

symbol_iter::symbol_iter(const symbol_iter& other)
  : str(other.str), sloc(other.sloc), eloc(other.eloc) {}

symbol_iter::~symbol_iter() {}

UStringView symbol_iter::operator*() {
  return str.substr(sloc, eloc-sloc);
}

symbol_iter& symbol_iter::operator++()
{
  if (sloc < str.size()) {
    sloc = eloc;
    eloc++;
    char c = str[sloc];
    if (c == '\\') {
      sloc++;
      eloc++;
    } else if (c == '<') {
      for (auto i = eloc; i < str.size(); i++) {
        if (str[i] == '>') {
          eloc = i + 1;
          break;
        }
      }
    }
    if (eloc > str.size()) eloc = str.size();
  }
  return *this;
}

bool symbol_iter::operator!=(const symbol_iter& o) const
{
  return str != o.str || sloc != o.sloc || eloc != o.eloc;
}

bool symbol_iter::operator==(const symbol_iter& o) const
{
  return str == o.str && sloc == o.sloc && eloc == o.eloc;
}

symbol_iter symbol_iter::begin()
{
  return symbol_iter(str);
}

symbol_iter symbol_iter::end()
{
  symbol_iter ret(str);
  ret.sloc = str.size();
  ret.eloc = str.size();
  return ret;
}

// main.cc
#include "iter.hpp"
#include <iostream>

int main(int argc, char** argv) {
  UStringView name(argv[1]);
  for (auto sym : symbol_iter(name)) {
    std::cout << sym << std::endl;
  }
}

当我在 C++2a 下编译它时，它完全符合我的预期：

$ g++ --std=c++2a main.cc
$ ./a.out 'xyz<q>'
x
y
z
<q>

但是当我用 C++23 编译时，我得到了错误

/usr/include/c++/11/bits/ranges_base.h:574:21: error: satisfaction of atomic constraint ‘requires(_Tp& __t) {std::ranges::__cust::begin(__t);std::ranges::__cust::end(__t);} [with _Tp = _Range]’ depends on itself
  574 |     concept range = requires(_Tp& __t)
      |                     ^~~~~~~~~~~~~~~~~~
  575 |       {
      |       ~              
  576 |         ranges::begin(__t);
      |         ~~~~~~~~~~~~~~~~~~~
  577 |         ranges::end(__t);
      |         ~~~~~~~~~~~~~~~~~
  578 |       };
      |       ~              

而且我无法通过谷歌搜索找到对此错误的任何解释。

main中的循环显示了我是如何使用它的（使用auto的 range-for 循环），尽管即使我删除循环也会出现错误（也就是说，即使代码中没有任何其他内容引用symbol_iter class）。

此外，如果我将UStringView更改为UStringView* ，除了operator*之外的所有地方（我试过这个，因为在代码库的其他地方有一个具有相同接口的迭代器，只是输入类型是指针而不是视图，错误是固定的）。

Answer 1

根据 ildjarn 和康桐蔚的评论，这似乎是 GCC 先前版本中的错误。

更基本的问题，我认为 Nicol Bolas 试图指出（我最初几次不理解），是我不应该尝试为单个 class 创建多个迭代器类型（就像我想要的那样到)，一个以前没有发现的错误，因为碰巧我之前尝试编写迭代器并没有破坏任何东西。

现在适用于两个编译器版本的 class 是

class symbol_iter
{
private:
  UStringView str;
public:
  symbol_iter(UStringView s) : str(s) {}
  ~symbol_iter() {}
  class iterator
  {
    friend symbol_iter;
  private:
    UStringView str;
    UStringView::size_type sloc = 0;
    UStringView::size_type eloc = 0;
  public:
    iterator(UStringView s);
    iterator(const iterator& other);
    ~iterator();
    UStringView operator*() const;
    iterator& operator++();
    bool operator!=(const symbol_iter::iterator& other) const;
    bool operator==(const symbol_iter::iterator& other) const;
  };
  iterator begin() const;
  iterator end() const;
};