Как я могу определить последнюю итерацию в цикле через std::map?
Вопрос
Я пытаюсь найти наилучший способ определить, нахожусь ли я на последней итерации цикла над картой, чтобы сделать что-то вроде следующего:
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
функция и т.д.Каков канонический метод?
Редактировать:никаких итераторов произвольного доступа к картам!
Решение
Канонический?Я не могу этого утверждать, но я бы предположил
final_iter = someMap.end();
--final_iter;
if (iter != final_iter) ...
Отредактированный исправить, как предложено KTC. (Спасибо!Иногда ты действуешь слишком быстро и путаешь самые простые вещи ...)
Другие советы
Начиная с 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
}
}
Хотя этот вопрос был задан некоторое время назад, я подумал, что им стоит поделиться.
Это кажется самым простым:
bool last_iteration = iter == (--someMap.end());
Если вы просто хотите использовать 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
}
}
Модифицировал Mark Ransom's, чтобы он действительно работал так, как задумано.
finalIter = someMap.end();
--finalIter;
if (iter != final_iter)
Удивлен, что никто до сих пор не упомянул об этом, но, конечно, в boost что-то есть ;)
Повышение. Следующий (и эквивалентный импульс.Предыдущий)
Ваш пример будет выглядеть следующим образом:
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
}
}
Следующий код был бы оптимизирован компилятором таким образом, чтобы быть лучшим решением для этой задачи как по производительности, так и по правилам ООП:
if (&*it == &*someMap.rbegin()) {
//the last iteration
}
Это лучший код по правилам ООП, потому что в std::map есть специальная функция-член rbegin для такого кода, как:
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 ) );
}
Использование std::for_each гарантирует, что цикл будет плотным и точным...Обратите внимание на введение функции foo(), которая принимает один аргумент (тип должен соответствовать тому, что содержится в someMap).Этот подход имеет дополнительное дополнение в виде 1 строки.Конечно, если Foo действительно мал, вы можете использовать лямбда-функцию и избавиться от вызова &Foo .
Зачем работать над поиском EOF, чтобы ничего ему не давать?
Просто исключите это;
for (iter = someMap.begin(); someMap.end() - 1; ++iter) {
//apply to all from begin to second last element
}
ПОЦЕЛУЙ (ПУСТЬ ЭТО БУДЕТ ПРОСТО)
Простой, но эффективный подход:
size_t items_remaining = someMap.size();
for (iter = someMap.begin(); iter != someMap.end(); iter++) {
bool last_iteration = items_remaining-- == 1;
}
Вот мой оптимизированный вариант:
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);
Как насчет этого, никто не упоминает "но"?..
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
}
}
это кажется простым, мм...
Полная программа:
#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
Вы можете просто извлечь элемент из карты перед итерацией, затем выполнить свою работу "последней итерации" вне цикла, а затем поместить элемент обратно в карта.Это ужасно плохо для асинхронного кода, но, учитывая, насколько плох остальной C ++ для параллелизма, я не думаю, что это будет проблемой.:-)