C++中的split_view和lazy_split_view有什么区别？

Question

我已经阅读了最新的草案，其中lazy_split_view添加了内容。

但后来我发现它split_view改名为lazy_split_view，而且又split_view更新了。

libstdc++最近还通过使用GCC Trunk版本https://godbolt.org/z/9qG5T9n5h实现了这一点

我这里有一个简单的天真的程序，它显示了两个视图的用法，但我看不到它们的区别：

#include <iostream>
#include <ranges>

int main(){

    std::string str { "one two three  four" };

    for (auto word : str | std::views::split(' ')) {
        for (char ch : word)
            std::cout << ch;
        std::cout << '.';
    }

    std::cout << '\n';

    for (auto word : str | std::views::lazy_split(' ')) {
        for (char ch : word)
            std::cout << ch;
        std::cout << '.';
    }

}

输出：

one.two.three..four.
one.two.three..four.

std::span<const char>直到我注意到使用 as两种视图时的差异。

在第一个std::views::split：：

for (std::span<const char> word : str | std::views::split(' '))

编译器接受我的代码。

在第二个中：std::views::lazy_split

for (std::span<const char> word : str | std::views::lazy_split(' ')) 

抛出编译错误。

我知道两者之间会有差异，但我无法轻易发现它们。这是 C++20 中的缺陷报告还是 C++23 中的新功能（有更改），还是两者都有？

Answer 1

我查看了相关论文（来自 Barry Revzin 的P2210R2）并split_view已重命名为lazy_split_view. 新的split_view不同之处在于它为您提供了不同的结果类型，保留源范围的类别。

例如，我们的字符串str是一个连续的范围，因此split将产生一个连续的子范围。以前它只会给你一个前进范围。如果您尝试执行多次操作或获取底层存储的地址，这可能会很糟糕。

从论文的例子来看：

std::string str = "1.2.3.4";
auto ints = str 
    | std::views::split('.')
    | std::views::transform([](auto v){
        int i = 0;
        std::from_chars(v.data(), v.data() + v.size(), i);
        return i;
    });

现在可以工作了，但是

std::string str = "1.2.3.4";
auto ints = str 
    | std::views::lazy_split('.')
    | std::views::transform([](auto v){
        int i = 0;
        // v.data() doesn't exist
        std::from_chars(v.data(), v.data() + v.size(), i);
        return i;
    });

不会，因为该范围v只是一个向前范围，不提供data()成员。

原答案

我的印象是split也一定是懒惰的（毕竟懒惰是范围提案的卖点之一），所以我做了一个小实验：

struct CallCount{
    int i = 0;

    auto operator()(auto c) {
        i++;
        return c;
    }

    ~CallCount(){
        if (i > 0) // there are a lot of copies made when the range is constructed
            std::cout << "number of calls: " << i << "\n";
    }
};


int main() {
    
    std::string str = "1 3 5 7 9 1";

    std::cout << "split_view:\n";

    for (auto word : str | std::views::transform(CallCount{}) | std::views::split(' ') | std::views::take(2)) {
    }

    std::cout << "lazy_split_view:\n";

    for (auto word : str | std::views::transform(CallCount{}) | std::views::lazy_split(' ') | std::views::take(2)) {
    }    
}

此代码打印（请注意，transform对字符串中的每个字符进行操作）：

split_view:
number of calls: 6
lazy_split_view:
number of calls: 4

那么会发生什么呢？

事实上，这两种观点都是懒惰的。但他们的懒惰程度却有所不同。我transform放在前面的split只是计算它被调用的次数。事实证明，它会急切地split计算下一个项目，而lazy_split一旦遇到当前项目后面的空白就会停止。

您可以看到该字符串str由数字组成，这些数字也标记了其字符索引（从 1 开始）。take(2)在我们看到 '3' 后应该停止循环str。确实lazy_split在“3”之后的空白处停止，但split在“5”之后的空白处停止。

这本质上意味着split急切地而不是懒惰地获取下一个项目。这种差异在大多数情况下可能并不重要，但它可能会影响性能关键代码。

我不知道这是否是这种变化的原因（我还没有读过这篇论文）。