std::for_each 处理多个迭代器

Question

lambda 表示法使 stl 算法更易于使用。我仍在学习决定什么时候有用，什么时候回退到老式的 for 循环。 通常，有必要迭代两个（或更多）相同大小的容器，以便相应的元素相关，但由于某种原因没有打包到同一个类中。

使用 for 循环来实现的函数如下所示：

template<typename Data, typename Property>
void foo(vector<Data>& data, vector<Property>& prop) {
    auto i_data = begin(data);
    auto i_prop = begin(prop);
    for (; i_data != data.end(); ++i_data, ++i_prop) {
        if (i_prop->SomePropertySatistfied()) {
            i_data->DoSomething();
        }
    }
}

为了使用for_each，我需要一个处理多个范围的版本；类似：

template<typename InputIter1, typename InputIter2, typename Function>
Function for_each_on_two_ranges(InputIter1 first1, InputIter1 last1, InputIter2 first2, Function f) {
    for (; first1 != last1; ++first1, ++first2) {
        f(*first1, *first2);
    }
    return f;
}

使用这个版本，上面的代码看起来像这样：

template<typename Data, typename Property>
void foo_two_ranges(vector<Data>& data, vector<Property>& prop) {
    for_each_on_two_ranges(begin(data), end(data), begin(prop), [](Data& d, Property& p) {
        if (p.SomePropertySatistfied()) {
            d.DoSomething();
        }
    });
}

是否有使用 stl 算法实现相同结果的等效方法？

编辑

我以在 boost::range 上运行的 boost::for_each 的形式找到了我的问题的确切答案。为了完整起见，我添加了答案，并附有示例代码。

Answer 1

1) STL 中的算法并不意味着涵盖所有可能的情况，如果您需要for_each_on_two_ranges，请编写它（如您所愿）并使用它。 STL 的美妙之处在于它的可扩展性非常好，而且您已经使用有用的新算法对其进行了扩展。

2) 如果这不起作用，您不必使用老式的 for 循环，而是可以使用花哨的新 for 循环！

正如另一个答案所说，boost::zip_iterator 是您在这里的朋友，但它不一定很难使用。这是使用zip_iterator实现的范围适配器的解决方案

template<typename Data, typename Property>
void foo(vector<Data>& data, vector<Property>& prop) {
    for (auto i : redi::zip(data, prop))
        if (i.get<1>().SomePropertySatistfied())
            i.get<0>.DoSomething();
}

zip 函数创建了一个带有 begin() 和 end() 成员的适配器，这些成员返回一个 boost::zip_iterator，因此循环变量是每个底层容器的元素的元组（并且因为它是一个可变参数模板，您可以对任意数量的容器执行此操作，因此您无需编写 for_each_for_three_ranges 和 for_each_for_four_ranges 等）

您也可以将其与for_each 一起使用

auto z = redi::zip(data, prop);
typedef decltype(z)::iterator::reference reference;

for_each(begin(z), end(z), [](reference i) {
    if (i.get<1>().SomePropertySatistfied()) {
        i.get<0>().DoSomething();
    }
});

Answer 2

在阅读了一些答案所建议的 boost::zip_iterator 和 boost::iterator_range 之后，我遇到了extension algorithms in boost::range，并发现我为两个范围编写的算法完全平行，但具有提升范围。

该示例的工作代码是

#include <boost/range/algorithm_ext/for_each.hpp>

template<typename Data, typename Property>
void foo_two_ranges(vector<Data>& data, vector<Property>& prop) {
    auto rng1 = boost::make_iterator_range(data.begin(), data.end());
    auto rng2 = boost::make_iterator_range(prop.begin(), prop.end());
    boost::for_each(rng1, rng2, [](Data& d, Property& p) {
        if (p.SomePropertySatistfied()) {
            d.DoSomething();
        }
    });
}

一些包装器和实用功能，类似于@Jonathan Wakely 所建议的，可以使它更加有用。

Answer 3

std::transform 有一个在两个序列上并行运行的重载。但是，如果您对收集结果不感兴趣，则需要一个空输出迭代器来吸收结果。