C++ 如何使用BOOST_FOREACH同时迭代两个向量？

我想用boostforeach复制以下内容

std::vector<int>::const_iterator i1;
std::vector<int>::const_iterator i2;
for( i1 = v1.begin(), i2 = v2.begin();
     i1 < v1.end() && i2 < v2.end();
     ++i1, ++i2 )
{
     doSomething( *i1, *i2 );
}

std:：vector:：const_迭代器i1；
std:：vector:：const_迭代器i2；
for（i1=v1.begin（），i2=v2.begin（）；
i1

如果您想使用

BOOST\u FOREACH

同时迭代两个向量，就像您在示例代码中所做的那样，那么您必须将这两个向量封装在一个包装类中，该类应该公开

begin

和

end

函数。这些函数返回用于在包装器上迭代的自定义迭代器，包装器内部将在两个向量上迭代。听起来不太好，但这是你必须做的

这是我第一次尝试实现这个（最小实现只是为了演示基本思想）：

输出：

1, 11
2, 12
3, 13
4, 14
5, 15

演示：

---

这只适用于实验和学习目的，因为我并不认为它是完美的。可以有很多改进。@Steve已经发布了boost的解决方案。

同时迭代两件事被称为“zip”（来自函数式编程），并且：

zip迭代器提供了对多个对象进行并行迭代的能力 同时控制序列。构造了一个zip迭代器 从迭代器的元组。移动zip迭代器将移动所有 并行迭代器。取消对zip迭代器的引用将返回一个元组 它包含取消引用各个迭代器的结果

请注意，它是一个迭代器，而不是一个范围，因此要使用

BOOST\u FOREACH

，必须将其中两个填充到一个or

对中。所以它并不漂亮，但只要小心一点，你可能会想出一个简单的
zip\u范围
，然后写：

BOOST_FOREACH(boost::tuple<int,int> &p, zip_range(v1, v2)) {
    doSomething(p.get<0>(), p.get<1>());
}

BOOST\u FOREACH（BOOST:：tuple&p，zip\u范围（v1，v2））{
doSomething（p.get（），p.get（））；
}

或2的特殊情况，使用
std:：pair
而不是
boost:：tuple

我想既然
doSomething
可能有参数
（int&，int&）
，实际上我们需要一个
元组。希望它能起作用。
多亏了史蒂夫·杰索普的回答和精彩的评论，我想出了以下解决方案，所以如果你觉得这很好，请先投票支持史蒂夫·杰索普的答案。（

#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
#包括
使用名称空间boost；
int main（int argc，字符**argv）{
std:：vector vecFirst=assign:：list_of（1）（2）（3）（43）（7）（13）；
std:：vector vecsond=assign:：list_of（53.45）（-23.545）（0.1574）（1.001）（0.0047）（9.7）；
增压自动（zipSequence，
生成迭代器范围(
生成zip迭代器（生成元组（vecFirst.begin（），vecSecond.begin（）），
生成zip迭代器（生成元组（vecFirst.end（），vecSecond.end（））
)
);
BOOST_FOREACH（BOOST_TYPEOF（*zipSequence.begin（））每个，zipSequence）{
std：：cout如果使用boost，我认为应该简单到：

#include <boost/foreach.hpp>
#include <boost/range/combine.hpp>
std::vector<int> v1;
std::vector<int> v2;

// iterate over values
int i1, i2;
BOOST_FOREACH(boost::tie(i1, i2), boost::combine(v1, v2))
    std::cout << i1+i2 << "\n"; // sums two vectors

// iterate over references
typedef boost::tuple<int&, int&> int_ref_tuple;
BOOST_FOREACH(int_ref_tuple tup, boost::combine(v1, v2))
    tup.get<0>() = tup.get<1>(); // assigns one vector to another

#包括
#包括
std：：向量v1；
std：：向量v2；
//迭代值
inti1，i2；
BOOST_FOREACH（BOOST:：tie（i1，i2），BOOST:：combine（v1，v2））
std：：cout Peccadillo：您可能想使用
！=
而不是
，这个问题的一些好答案也可以在这里找到：可能重复，很好，不知道zip迭代器（从不需要它：-））+1@Vlad当前位置我也不知道，但只要你知道它叫“zip”）我从来没有做过函数式编程，所以我甚至没听说过“zip”（除了我们谈论压缩）。很高兴知道……或者他可以只
std:make\u pair（beg，end）
，因为Boost\u FOREACH也接受这些范围。（其中
beg
是
make\u-zip\u迭代器（make\u-tuple（v1.begin（），v2.begin（））
etc@Cubbi：说得好，我忘了。而且
std:：make_pair（beg，end）；
比
boost:：iterator_range（beg，end）；
略短。它是从boost 1.56开始记录的：
BOOST_FOREACH(boost::tuple<int,int> &p, zip_range(v1, v2)) {
    doSomething(p.get<0>(), p.get<1>());
}

#include <iostream>
#include <vector>

#include <boost/typeof/typeof.hpp>
#include <boost/typeof/std/vector.hpp>

#include <boost/foreach.hpp>
#include <boost/assign/list_of.hpp>
#include <boost/tuple/tuple.hpp>
#include <boost/iterator/zip_iterator.hpp>
#include <boost/range/iterator_range.hpp>

using namespace boost;

int main(int argc, char **argv) {
    std::vector<int> vecFirst = assign::list_of(1)(2)(3)(43)(7)(13);
    std::vector<double> vecSecond = assign::list_of(53.45)(-23.545)(0.1574)(1.001)(0.0047)(9.7);

    BOOST_AUTO(zipSequence,
       make_iterator_range(
           make_zip_iterator(make_tuple(vecFirst.begin(), vecSecond.begin())), 
           make_zip_iterator(make_tuple(vecFirst.end(), vecSecond.end()))
       )
    );

    BOOST_FOREACH( BOOST_TYPEOF(*zipSequence.begin()) each, zipSequence) {
       std::cout << "First vector value : " << each.get<0>() 
                 << " - Second vector value : " << each.get<1>() 
                 << std::endl;
    }
}

#include <boost/foreach.hpp>
#include <boost/range/combine.hpp>
std::vector<int> v1;
std::vector<int> v2;

// iterate over values
int i1, i2;
BOOST_FOREACH(boost::tie(i1, i2), boost::combine(v1, v2))
    std::cout << i1+i2 << "\n"; // sums two vectors

// iterate over references
typedef boost::tuple<int&, int&> int_ref_tuple;
BOOST_FOREACH(int_ref_tuple tup, boost::combine(v1, v2))
    tup.get<0>() = tup.get<1>(); // assigns one vector to another