如何将 BOOST_FOREACH 与两个 std::map 一起使用？

Question

我的代码基本上如下所示：

std::map<int, int> map1, map2;
BOOST_FOREACH(int i, map1)
{
    // do steps 1-5 here...
}
BOOST_FOREACH(int i, map2)
{
    // do steps 1-5 (identical to above) here...
}

有没有办法连接映射以消除第二个循环中的重复代码？ 或者一种扩展 BOOST_FOREACH 一次性迭代两个不同映射的方法？ 显然我不想增加程序的时间复杂度（否则我可以创建一个新地图并插入其中map1和map2）。 我有一种感觉，我在这里缺少一些基本的东西。

Answer 1

您可以定义一个函数：

typedef std::map<int, int> IntMap;

void doStuffWithInt(IntMap::value_type &i)
{
  // steps 1 to 5
}

BOOST_FOREACH(IntMap::value_type &i, map1)
  doStuffWithInt(i);
BOOST_FOREACH(IntMap::value_type &i, map2)
  doStuffWithInt(i);

尽管在这种情况下使用 std::for_each 可能更简单：

for_each(map1.begin(), map1.end(), doStuffWithInt);
for_each(map2.begin(), map2.end(), doStuffWithInt);

Answer 2

这里的想法是编写一种特殊类型的迭代器来虚拟地合并两个容器，就 BOOST_FOREACH 而言。 请注意，我不会从两个现有容器中创建新容器。 我只是从第一个容器的 end() 迭代器跳转到第二个容器的 begin() 迭代器。
我没有尝试编写实际的 merged_iterator 类，但虽然写起来可能有点长，但技术上并不困难。 事实上，我很惊讶没有使用谷歌找到类似的东西。 不过我没找多久！

template<typename Container>
boost::iterator_range<
  merged_iterator<Container::iterator>
  >
concat_containers( Container& c1, Container& c2 )
{
  typedef merged_iterator<typename Container::iterator> MergedIterator;
  typedef boost::iterator_range<MergedIterator> IteratorRange;
  return IteratorRange(
    MergeIterator( c1.begin(), c1.end(), c2.begin(), c2.end() ),
    MergeIterator( c2.end(), c1.end(), c2.begin(), c2.end() ) );
}

// Now use a bit of magic to define merged_iterator<...>
// And you'll be able to write

BOOST_FOREACH( std::pair<int, int> i, concat_containers( map1, map2 ) )
{
// Do whatever you want here
}

Answer 3

除了我推荐的1800的解决方案之外，还有各种hacky解决方案：

for (int stage = 0; stage < 2; stage++) {
    BOOST_FOREACH(int i, stage == 0 ? map1 : map2) {
        ...
    }
}

typedef std::map<int, int> intmap;
std::vector<intmap *> v;
v.push_back(&map1);
v.push_back(&map2);
BOOST_FOREACH(intmap *m, v) {
    BOOST_FOREACH(int i, *m) {
        ...
    }
}

注意：当我看到同事这样写代码时，有时我会忍不住想掐死他们。 使用风险自负。

Answer 4

最简单的方法是这样的：

std::map<int, int> map1, map2;
int key, value;
BOOST_FOREACH(boost::tie(key, value), boost::join(map1, map2))
{
    // do steps 1-5 here...
}

不用担心这些逗号不会因为括号而使预处理器感到困惑。

Answer 5

在我的头顶上，我会尝试

std::map<int, int> map1, map2;
std::map<int, int>& maps = { map1, map2 }
BOOST_FOREACH(std::map<int, int> map, maps)
  BOOST_FOREACH(int i, map)
  {
      // do steps 1-5 here...
  }

Answer 6

此处进行了解释。

你可以这样做：

std::map<int,int> m;
typedef std::pair<int,int> pair_t;
BOOST_FOREACH(pair_t p, m)