如何检测 std::map 循环中的最后一次迭代？

Question

我试图找出最好的方法来确定我是否处于地图上循环的最后一次迭代中，以便执行如下操作：

for (iter = someMap.begin(); iter != someMap.end(); ++iter) {
    bool last_iteration;
    // do something for all iterations
    if (!last_iteration) {
        // do something for all but the last iteration
    }
}

似乎有几种方法可以做到这一点：随机访问迭代器， distance 函数等。规范方法是什么？

编辑：地图没有随机访问迭代器！

Answer 1

典范？ 我不能这么说，但我建议

final_iter = someMap.end();
--final_iter;
if (iter != final_iter) ...

编辑按照KTC.（谢谢！有时你走得太快，会把最简单的事情搞砸......）

Answer 2

从 C++11 开始，您还可以使用 std::next()

   for (auto iter = someMap.begin(); iter != someMap.end(); ++iter) { 
        // do something for all iterations
        if (std::next(iter) != someMap.end()) {
            // do something for all but the last iteration
        }
    }

虽然这个问题是不久前提出的，但我认为值得分享。

Answer 3

这看起来是最简单的：

bool last_iteration = iter == (--someMap.end());

Answer 4

如果您只想使用 ForwardIterator，这应该可以工作：

for ( i = c.begin(); i != c.end(); ) {
        iterator cur = i++;
        // do something, using cur
        if ( i != c.end() ) {
                // do something using cur for all but the last iteration
        }
}

Answer 5

修改了 Mark Ransom 的，使其实际上按预期工作。

finalIter = someMap.end();
--finalIter;
if (iter != final_iter)

Answer 6

令人惊讶的是还没有人提到它，但当然 boost 有一些东西;)

Boost.Next（以及等效的 Boost.Prior）

您的示例如下所示：

for (iter = someMap.begin(); iter != someMap.end(); ++iter) {
    // do something for all iterations
    if (boost::next(iter) != someMap.end()) {
        // do something for all but the last iteration
    }
}

Answer 7

以下代码将由编译器进行优化，以便根据性能和 OOP 规则成为此任务的最佳解决方案：

if (&*it == &*someMap.rbegin()) {
    //the last iteration
}

这是 OOP 规则的最佳代码，因为 std::map 有一个特殊的成员函数 rbegin 用于代码如下：

final_iter = someMap.end();
--final_iter;

Answer 8

为什么要努力寻找 EOF，这样你就不会给它一些东西。

简单地，排除它；

for (iter = someMap.begin(); someMap.end() - 1; ++iter) {
    //apply to all from begin to second last element
}

KISS（保持简单）

Answer 9

#include <boost/lambda/lambda.hpp>
#include <boost/lambda/bind.hpp>
#include <algorithm>

using namespace boost::lambda;

// call the function foo on each element but the last...
if( !someMap.empty() )
{
  std::for_each( someMap.begin(), --someMap.end(), bind( &Foo, _1 ) );
}

使用 std::for_each 将确保循环紧密且准确...请注意函数 foo() 的引入，该函数采用单个参数（类型应与 someMap 中包含的内容匹配）。 此方法还增加了 1 行。 当然，如果 Foo 真的很小，您可以使用 lambda 函数并摆脱对 &Foo 的调用。

Answer 10

这个怎么样，没有人提到，但是……

for (iter = someMap.begin(); iter != someMap.end(); ++iter) {
    // do something for all iterations
    if (iter != --someMap.end()) {
        // do something for all but the last iteration
    }
}

这看起来很简单，嗯……

Answer 11

对于喜欢 C++11 基于范围的循环的人：

    for (const auto& pair : someMap) {
      if (&pair != &*someMap.rbegin()) ...
    }

请注意，此处仅引用类型有效，自动配对 无效

Answer 12

一个简单而有效的方法：

  size_t items_remaining = someMap.size();

  for (iter = someMap.begin(); iter != someMap.end(); iter++) {
    bool last_iteration = items_remaining-- == 1;
  }

Answer 13

完整程序：

#include <iostream>
#include <list>

void process(int ii)
{
   std::cout << " " << ii;
}

int main(void)
{
   std::list<int> ll;

   ll.push_back(1);
   ll.push_back(2);
   ll.push_back(3);
   ll.push_back(4);
   ll.push_back(5);
   ll.push_back(6);

   std::list<int>::iterator iter = ll.begin();
   if (iter != ll.end())
   {
      std::list<int>::iterator lastIter = iter;
      ++ iter;
      while (iter != ll.end())
      {
         process(*lastIter);
         lastIter = iter;
         ++ iter;
      }
      // todo: think if you need to process *lastIter
      std::cout << " | last:";
      process(*lastIter);
   }

   std::cout << std::endl;

   return 0;
}

该程序产生：

 1 2 3 4 5 | last: 6

Answer 14

这是我的优化方案：

iter = someMap.begin();

do {
    // Note that curr = iter++ may involve up to three copy operations
    curr = iter;

    // Do stuff with curr

    if (++iter == someMap.end()) {
        // Oh, this was the last iteration
        break;
    }

    // Do more stuff with curr

} while (true);

Answer 15

您可以在迭代之前从地图中取出一个元素，然后在循环之外执行“最后一次迭代”工作，然后将元素放回地图中。 这对于异步代码来说非常糟糕，但考虑到 C++ 的其余部分对于并发性来说有多糟糕，我认为这不会成为问题。 :-)