std :: for_each处理多个迭代器范围

Question

lambda表示法使得stl算法更易于访问。我仍然在学习如何决定什么时候有用，什么时候回到老式的循环。 通常，就有必要迭代相同大小的两个（或多个）容器中，以使得相应的元件是相关的，但由于某些原因未打包到同一类别。

一个函数中使用一个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 ::升压::范围运行的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

使用10

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

std::transform具有并行地对两个序列进行操作的过载。如果你不想收集任何结果，你需要一个空输出迭代器来吸收结果。

Answer 3

上的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建议类似，可以让这个更可用。