为什么 Ranges 库中的 std::views::take_while 需要 const 谓词？ 背景故事为什么这是个坏主意为什么约束不同你应该怎么做

如何解决为什么 Ranges 库中的 std::views::take_while 需要 const 谓词？ 背景故事为什么这是个坏主意为什么约束不同你应该怎么做

TL;DR：我正在尝试使用 范围 和来自 Ranges library 的相应范围适配器。范围适配器 std::views::take_while 和 std::views::filter 都采用谓词从输入序列中排除某些元素。为什么 take_while 采用 const 谓词而 filter 不采用？

背景故事

我有一个 std::vector<int> 并想对其进行迭代，但我想在点击 5 时停止迭代。通过使用范围适配器 std::views::take_while，我可以实现如下：

std::vector<int> v { 8,2,5,6 };

for (int i : v | std::views::take_while([](int i) { return i != 5; })) {
    std::cout << "Value: " << i << std::endl;
}

输出：

值：8 值：2

但是，我现在也想处理 5，因此循环必须进一步运行一个迭代步骤。我没有找到合适的范围适配器，所以我写了以下有状态的 lambda 表达式：

auto cond = [b = true](int i) mutable {
    return b ? b = (i != 5),true : false;
};

这个 lambda 表达式会记住条件 i != 5 何时被违反，并在下一次调用时返回 false。然后我将它传递给 std::views::take_while 如下：

for (int i : v | std::views::take_while(cond)) {
    std::cout << "Value: " << i << std::endl;
}

但是，对于上面的代码，编译器会抛出一个long error message。由于找不到问题，我仔细检查了 std::views::take_while 的声明，发现谓词 Pred 必须是 const。为了寻找替代方案，我检查了 std::views::filter 的声明。有趣的是，Pred 在这里不必须是const。因此，我将上述可变 lambda 传递给范围适配器 std::views::filter，如下所示：

for (int i : v | std::views::filter(cond)) {
    std::cout << "Value: " << i << std::endl;
}

此代码编译并提供所需的输出：

值：8 价值：2
价值：5

Code on Wandbox

这引出了我的问题：为什么 std::views::take_while 是 const 谓词，而 std::views::filter 不是？

解决方法

为什么这是个坏主意

让我们生成一个编译版本，看看它实际做了什么：

struct MutablePredicate {
    mutable bool flag = true;

    auto operator()(int i) const -> bool {
        if (flag) {
            flag = (i != 5);
            return true;
        } else {
            return false;
        }
    }
};

std::vector<int> v = {8,2,5,6};
auto r = v | std::views::take_while(MutablePredicate{});

fmt::print("First: {}\n",r);
fmt::print("Second: {}\n",r);

这将根据需要第一次打印 {8,5}。然后第二次{}。当然，因为我们修改了谓词，所以我们得到了完全不同的行为。这完全打破了这个范围的语义（因为你的谓词失败是平等的保留），和操作的种种只是完全失败结果。

结果 take_view 是一个随机访问范围。但是想想当你使用迭代器时会发生什么：

std::vector<int> v = {8,6};
auto r = v | std::views::take_while(MutablePredicate{});

auto it = r.begin();
it += 2;                // this is the 5
assert(it != r.end());  // does not fire,because we're not at the end
assert(it == r.end());  // does not fire,because we're at the end??

这太奇怪了，让推理变得不可能。

为什么约束不同

在C ++ 20尝试范围适配器以通过围绕优化最小化模板实例的数量 “的 simple-view ”：V是 {{1 }} 如果 simple-view 和 V 都是具有相同迭代器/哨兵类型的范围。对于这些情况，适配器不能同时提供V const和begin() ...他们的只是的提供，后者（因为在这些情况下没有区别，而且{{1} } 总是有效，所以我们就去做）。

我们的案例是一个begin() const，因为begin() const只提供simple-view。无论我们是否将该类型迭代为 ref_view<vector<int>>，我们仍然会从中得到 begin() const。

其结果是，const为了支持vector<int>::iterator需要要求take_while_view是一元谓词，不只是begin() const。由于 Pred const 无论如何都必须保持相等性，因此只要求 Pred 是一元谓词而不是潜在地支持 Pred if only {{1 }} but not Pred const 是一元谓词。这不是一个值得支持的有趣案例。

begin() /* non-const */ 不是 Pred 可迭代的，因此不必考虑这个问题。它永远只能作为非 - Pred const，所以没有filter_view，它曾经意味深长地要考虑作为一个谓词

你应该怎么做

因此，如果您实际上不需要惰性求值，我们可以急切地计算结束迭代器：

const

但如果您确实需要惰性求值，一种方法是创建您自己的适配器。对于双向+范围，我们可以定义一个哨兵，以便我们匹配迭代器，如果（a）它在底层视图基的末尾或（b）它不在范围的开头并且前一个迭代器匹配底层视图的结束。

是这样的（将仅工作在具有美景的const，因为它才有意义为Pred const的适配范围）：

auto e = std::ranges::find_if(v,[](int i){ return i == 5; });
if (e != v.end()) {
    ++e;
}
auto r = std::ranges::subrange(v.begin(),e);
// use r somehow

出于演示的目的，我们可以使用 libstdc++ 的内部结构使其可管道化：

.base()

现在，因为我们遵守所有库组件的所有语义约束，所以我们可以只使用适应范围作为范围：

and_one

Demo。

,

std::indirect_unary_predicate 必须是 std::predicate，const 必须是 a std::regular_invocable。而那需要：

invoke 函数调用表达式应保持相等性 ([concepts.equality])，不得修改函数对象或参数。

您的 lambda 不是“保持平等”，因为相同的输入可以产生不同的输出，并且它肯定会修改函数对象。由于您的类型不满足概念的非句法条件，您的代码具有 UB。

所以说真的，一个是 const 还是另一个不是都没有关系；这些概念实际上要求他们表现得好像他们是 fetch("jsonpage") .then((res) => res.json()) .then((data) => { for (const number of Object.keys(data.vendors)) { let newVendor = document.createElement("li"); newVendor.textContent = data.vendors[number].name; ulList.appendChild(newVendor); } }) .catch(console.error); 。