STL算法的可组合性

Question

STL 算法在 C++ 中非常有用。但让我恼火的一件事是它们似乎缺乏可组合性。

例如，假设我有一个 vector> 并且希望将其转换为仅包含 第二个的 vector 该对的成员。这很简单：

std::vector<std::pair<int, int>> values = GetValues();
std::vector<int> result;

std::transform(values.begin(), values.end(), std::back_inserter(result),
    [] (std::pair<int, int> p) { return p.second; });

或者也许我想过滤向量以仅查找first成员为偶数的那些对。也很简单：

std::vector<std::pair<int, int>> values = GetValues();
std::vector<std::pair<int, int>> result;

std::copy_if(values.begin(), values.end(), std::back_inserter(result),
    [] (std::pair<int, int> p) { return (p.first % 2) == 0; });

但是如果我想两者都做怎么办？没有 transform_if 算法，并且同时使用 transform 和 copy_if 似乎需要分配一个临时 vector 来保存中间结果：

std::vector<std::pair<int, int>> values = GetValues();
std::vector<std::pair<int, int>> temp;
std::vector<int> result;

std::copy_if(values.begin(), values.end(), std::back_inserter(temp),
    [] (std::pair<int, int> p) { return (p.first % 2) == 0; });

std::transform(values.begin(), values.end(), std::back_inserter(result),
    [] (std::pair<int, int> p) { return p.second; });

这对我来说似乎相当浪费。我能想到的避免临时向量的唯一方法是放弃 transform 和 copy_if 并简单地使用 for_each （或常规的 for 循环，无论哪个适合你的喜好）：

std::vector<std::pair<int, int>> values = GetValues();
std::vector<int> result;

std::for_each(values.begin(), values.end(),
    [&result] (std::pair<int, int> p) 
        { if( (p.first % 2) == 0 ) result.push_back(p.second); });

我在这里错过了什么吗？有没有一种好方法可以将两个现有的STL算法组合成一个新的算法，而不需要临时存储？

Answer 1

早在 2000 年，这个问题就已经被注意到。 Gary Powell 和 Martin Weiser 提出了“视图”的概念，并创造了“视图模板库”这个名称。当时它并没有流行起来，但这个想法是有道理的。 “视图”适配器本质上应用了动态转换。例如，它可以调整value_type。

现在我们有了 C++0x，这个概念可能应该重新讨论。自 2000 年以来，我们在泛型编程方面取得了相当大的进展。

例如，让我们使用 vector> 到 vector 示例。这可能非常简单：

std::vector<std::pair<int, int>> values = GetValues();
vtl2::view v (values, [](std::pair<int, int> p) { return p.first }); 
std::vector<int> result(view.begin(), view.end());

或者，使用 boost::bind 技术，甚至更简单：

std::vector<std::pair<int, int>> values = GetValues();
vtl2::view v (values, &std::pair<int, int>::first); 
std::vector<int> result(view.begin(), view.end());

Answer 2

从 C++20 开始，您可以使用 std::ranges::copy 与范围适配器 std::views::filter 和 std::views::values 来自 范围库如下：

int main() {
    std::vector<std::pair<int, int>> values = { {1,2}, {4,5}, {6,7}, {9,10} };
    std::vector<int> result;

    auto even = [](const auto& p) { return (p.first % 2) == 0; };
    std::ranges::copy(values | std::views::filter(even) | std::views::values,
                      std::back_inserter(result));

    for (int i : result)
        std::cout << i << std::endl;

    return 0;
}

输出：

5
7

在上面的解决方案中，没有为中间结果创建临时向量，因为视图适配器创建不包含元素的范围。这些范围只是输入向量的视图，但具有自定义的迭代行为。

Wandbox 上的代码

Answer 3

不确定这是否仍然有效，但是......
一个新的仅轻型等待标头的库，可以执行您所描述的操作。 Doc 谈论了惰性求值和 com 可组合生成器。

文档片段：

• 从文件“test.txt”中读取最多 10 个整数。
• 过滤偶数，对它们求平方并对它们的值求和。

    int total = lz::read<int>(ifstream("test.txt")) | lz::limit(10) |
                lz::filter([](int i) { return i % 2 == 0; }) |
                lz::map([](int i) { return i *  i; }) | lz::sum();

您可以将该行拆分为多个表达式。

    auto numbers = lz::read<int>(ifstream("test.txt")) | lz::limit(10);
    auto evenFilter = numbers | lz::filter([](int i) { return i % 2 == 0; });
    auto squares = evenFilter | lz::map([](int i) { return i *  i; });
    int total = squares | lz::sum();

• 尽管这个表达式被分割为多个变量赋值，但它的效率并没有降低。
• 每个中间变量简单地
  描述要执行的代码单元。全部放在堆栈中。

https://github.com/SaadAttieh/lazyCode

Answer 4

你说得对。您可以使用 Boost。范围适配器来实现组合。

Answer 5

我认为问题是不幸的是，结构

1. C++使用两个迭代器来表示序列
2. C++函数是单值的，

所以你不能链接它们，因为函数不能返回“序列”。

一种选择是使用单对象序列（喜欢 boost 的范围方法）。通过这种方式，您可以将一个处理的结果合并为另一个处理的输入...（一个对象 -> 一个对象）。

在标准 C++ 库中，处理过程是（两个对象 -> 一个对象），很明显，如果不命名临时对象，就无法链接它。