¿Cómo puedo detectar la última iteración en un bucle sobre std:: map?

Esto parece ser el más simple:

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

Desde C++11, también puedes usar 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
        }
    }

Aunque la pregunta se hizo hace un tiempo, pensé que valdría la pena compartirla.

Si solo desea usar un ForwardIterator, esto debería funcionar:

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
        }
}

Mark Ransom modificado para que realmente funcione como estaba previsto.

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

Sorprendido nadie lo mencionó todavía, pero por supuesto boost tiene algo;)

Boost.Siguiente (y el Impulso equivalente.Anterior)

Su ejemplo se vería como:

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
    }
}

El siguiente código sería optimizado por un compilador para ser la mejor solución para esta tarea tanto por rendimiento como por reglas OOP:

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

Este es el mejor código por reglas OOP porque std:: map tiene una función miembro especial rbegin para el código como:

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

#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 ) );
}

El uso de std::for_each asegurará que el bucle sea apretado y preciso... Tenga en cuenta la introducción de la función foo() que toma un solo argumento (el tipo debe coincidir con lo que está contenido en someMap). Este enfoque tiene la adición añadida de ser 1 línea. Por supuesto, si Foo es realmente pequeño, puede usar una función lambda y deshacerse de la llamada a &Foo.

Por qué trabajar para encontrar el EOF para que no le des algo.

Simplemente, excluirlo;

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

KISS (MANTENERLO SIMPLEMENTE SIMPLE)

Un enfoque simple, pero eficaz:

  size_t items_remaining = someMap.size();

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

Aquí está mi toma optimizada:

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);

Qué tal esto, nadie lo menciona sino...

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
    }
}

Esto parece simple, mm...

Programa completo:

#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;
}

Este programa produce:

 1 2 3 4 5 | last: 6

Simplemente puede sacar un elemento del mapa antes de la iteración, luego realizar su trabajo de "última iteración" fuera del bucle y luego volver a colocar el elemento en el mapa. Esto es terriblemente malo para el código asíncrono, pero teniendo en cuenta lo malo que es el resto de C++ para la concurrencia, no creo que sea un problema. :-)