你将如何为 C++20 范围实现一个只调用生成器 function 的惰性“范围工厂”？

Question

我喜欢你可以用std::views::iota制作的惰性范围的想法，但很惊讶地发现iota目前是标准中唯一类似的东西； 它是除了views::single和views::empty之外唯一的“范围工厂”。 例如，当前不存在与std::generate等效的范围工厂。

但是我注意到，通过在 iota 上使用转换视图并忽略 iota 传递给转换的值来实现generate的语义是微不足道的，即

#include <iostream>
#include <ranges>
#include <random>

template<typename F>
auto generate1(const F& func) {
    return std::views::iota(0) | std::views::transform([&func](int) {return func(); });
}

std::random_device dev;
std::mt19937 rng(dev());

int main() {

    auto d6 = []() {
        static std::uniform_int_distribution<> dist(1, 6);
        return dist(rng);
    };

    for (int v : generate1(d6) | std::views::take(10)) {
        std::cout << v << ' ';
    }
    std::cout << '\n';
}

我的问题是什么是“真正的方式”来实现这样的事情？ 制作一个范围视图 object 是可管道的，而不仅仅是使用iota 。

我尝试从ranges::view_interface继承——不知道这是否是正确的方法——只是让它返回一个调用生成器 function 的虚拟迭代器，但我的代码不起作用，因为它需要 pipe 的部分std::views::take的范围视图，以免导致无限循环。 我在此处定义的 object 最终无法通过管道传输。

#include <iostream>
#include <ranges>
#include <random>

template<typename F>
class generate2 : public std::ranges::view_interface<generate2<F>>
{
    using value_type = decltype(std::declval<F>()());

    class iterator {
        const F* gen_func_;
    public:
        iterator(const F* f) : gen_func_(f)
        {}

        value_type operator*() const {
            return (*gen_func_)();
        }

        bool operator!=(const iterator&) {
            return true;
        }

        iterator& operator++() {
            return *this;
        }
    };

    F generator_func_;

public:

    generate2(const F& f) : generator_func_(f) {
    }

    iterator begin()  {
        return iterator(&generator_func_);
    }

    iterator end()  {
        return iterator(nullptr);
    }
};

std::random_device dev;
std::mt19937 rng(dev());

int main() {

    auto d6 = []() {
        static std::uniform_int_distribution<> dist(1, 6);
        return dist(rng);
    };

    // the following doesnt compile because of the pipe...
    for (int v : generate2(d6) | std::views::take(10)) { 
        std::cout << v << ' ';
    }
    std::cout << '\n';
}

Answer 1

generate2之所以不能工作是因为它没有 model range概念，即它的begin()返回的类型没有 modelinput_iterator ，因为input_iterator要求difference_type和value_type存在并且i++是一个有效的表达式。

另外，你的迭代器不满足sentinel_for<iterator> ，这意味着它不能作为自己的哨兵，因为sentinel_for要求semiregular需要default_initializable ，所以你还需要为它添加默认构造函数。

您还需要将bool operator.=(...)重写为bool operator==(...) const因为operator!=不会反向合成operator== 。 但是在你的情况下使用default_sentinel_t作为哨兵更容易。

如果将它们添加到iterator中，您会发现代码格式正确：

class iterator {
 public:
  using value_type = decltype(std::declval<F>()());
  using difference_type = std::ptrdiff_t;
  iterator() = default;
  void operator++(int);
  bool operator==(const iterator&) const {
    return false;
  }
  // ...
};

但是iterator的operator*()不满足equality-preserving的要求，也就是说前后两次调用得到的结果是不相等的，也就是说这会是undefined behavior。

可以参考ranges::istream_view的实现，使用一个成员变量来缓存每一个生成的结果，那么每次调用iterator::operator*()时只需要返回缓存的值即可。

template<typename F>
class generate2 : public std::ranges::view_interface<generate2<F>> {
 public:
  auto begin() {
    value_ = generator_func_();
    return iterator{*this};
  }

  std::default_sentinel_t end() const noexcept { return std::default_sentinel; }

  class iterator {
   public:
   //...
    value_type operator*() const {
      return parent_->value_;
    }
   private:
    generate2* parent_;
  };

 private:
   F generator_func_;
   std::remove_cvref_t<std::invoke_result_t<F&>> value_; 
};