Как я могу пропустить элементы в цикле for на основе диапазона на основе «индекса»?

Часто нам нужно сделать что-то особенное с первым элементом контейнера и перебрать оставшиеся элементы.

Я удивлен, увидев, что до сих пор никто не предложил это решение:

  auto it = std::begin(container);

  // do your special stuff here with the first element

  ++it;

  for (auto end=std::end(container); it!=end; ++it) {

      // Note that there is no branch inside the loop!

      // iterate over the rest of the container
  }

Большое преимущество заключается в том, что ветвь перемещается из цикла. Это делает цикл намного проще, и, возможно, компилятор также может лучше оптимизировать его.

Если вы настаиваете на цикле for на основе диапазона, возможно, самый простой способ сделать это (есть и другие, более уродливые способы):

std::size_t index = 0;

for (auto& elem : container) {

  // skip the first element
  if (index++ == 0) {
     continue;
  }

  // iterate over the rest of the container
}

Однако я бы серьезно переместил ветвь из цикла, если все, что вам нужно, это пропустить первый элемент.

Boost предоставляет хороший лаконичный способ сделать это:

std::vector<int> xs{ 1, 2, 3, 4, 5 };
for (const auto &x : boost::make_iterator_range(xs.begin() + 1, xs.end())) {
  std::cout << x << " ";
}
// Prints: 2 3 4 5

Вы можете найти make_iterator_range в заголовке boost/range/iterator_range.hpp.

Нет, вы не можете получить итератор в цикле for на основе диапазона (без поиска элемента в контейнере, конечно). Итератор определен стандартом как имеющий имя __begin, но это только для демонстрации. Если вам нужен итератор, предполагается, что вы используете обычный цикл for. Причина, по которой существует цикл for на основе диапазона, заключается в тех случаях, когда вам не нужно заботиться об обработке итерации самостоятельно.

С auto и std::begin и std::end ваш цикл for должен быть очень простым:

for (auto it = std::begin(container); it != std::end(container); it++)

При переборе элементов всегда предпочитайте использовать алгоритм и используйте простой for цикл, только если ни один из алгоритмов не подходит.

Выбор правильного алгоритма зависит от того, что вы хотите делать с элементами... о чем вы нам не сказали.

Если вы хотите пропустить первый элемент, пример дампа:

if (!container.empty()) {
   for_each(++container.begin(), container.end(), [](int val) { cout << val; });
}

Как насчет использования простого цикла for с iteratos:

for(auto it = container.begin(); it != container.end(); it++)
{
    if(it == container.begin())
    {
        //do stuff for first
    }
    else
    {
        //do default stuff
    }
}

Это не основано на диапазоне, но оно функционально. Если вы все еще хотите использовать цикл диапазона:

int counter = 0;
for(auto &data: container)
{
    if(counter == 0)
    {
        //do stuff for first
    }
    else
    {
        //do default stuff
    }
    counter++;
}

Невозможно узнать, как далеко элемент находится внутри контейнера, не имея итератора, указателя или навязчивого индекса. Вот простой способ сделать это:

int index= 0;
for (auto& elem: container) 
{
  if (index++ == something)
     continue;

  // do something with remaining elements
}

Если вы хотите пропустить первый элемент, другой способ — использовать std::deque и pop_front для первого элемента. Затем вы можете выполнить цикл range for с контейнером, как обычно.

Когда мне нужно сделать что-то подобное в контейнере с произвольным доступом, я обычно перебираю индексы.

for( std::size_t i : indexes( container ) ) {
  if (i==0) continue;
  auto&& e = container[i];
  // code
}

единственная сложная часть — написать indexes, которая возвращает диапазон итераторов, которые boost вызывает counting. Создать базовый итерируемый диапазон из итераторов легко: либо используйте концепцию диапазона boost, либо сверните свою собственную.

Базовый диапазон для произвольного типа итератора:

template<typename Iterator>
struct Range {
  Iterator b; Iterator e;
  Range( Iterator b_, Iterator e_ ):b(b_), e(e_) {};
  Iterator begin() const { return b; }
  Iterator end() const { return e; }
};

что вы можете придумать кучу, но это ядро.

Я бы старался избегать использования итераторов, потому что идея цикла for на основе for чтобы избавиться от них. Начиная с C++20, чтобы пропустить первый элемент в вашем container, Я бы выбрал один из следующих подходов. Я также включаю, для полноты картины, как обрабатывать первый элемент отдельно:

1. Обработка первого элемента вне цикла

   Вы можете использовать container.front(), который существует для всех контейнеров последовательности, чтобы получить доступ к первому элементу. Однако вы должны убедиться, что контейнер не пуст, чтобы избежать ошибки сегментации. Затем, чтобы пропустить первый элемент (или более) в цикле, вы можете использовать адаптер диапазона std::views::drop из библиотеки диапазонов. Все вместе это выглядит следующим образом:

   std::vector<int> container { 1, 2, 3 };
   
   if(!container.empty()) {
       // do something with first element
       std::cout << "First element: " << container.front() << std::endl;
   }
   
   for (auto& elem : container | std::views::drop(1)) {
       // do something with remaining elements
       std::cout << "Remaining element: " << elem << std::endl;
   }
   

   Вместо container.front() вы также можете использовать другой цикл for на основе диапазона вместе с адаптером диапазона std::views::take(1)< /а>. Преимущество take() и drop() в том, что они работают безопасно, даже если их аргументы превышают количество элементов в вашем container.

2. Обработка первого элемента внутри цикла

   Вы можете использовать инит-оператор в цикле for на основе диапазона для определения логического флага (или даже счетчика). Таким образом, флаг виден только в рамках цикла. Вы можете использовать флаг внутри цикла следующим образом:

   std::vector<int> container { 1, 2, 3 };
   
   for(bool isFirst(true); auto& elem : container) {
       if(isFirst) {
           // do something with first element
           std::cout << "First element: " << elem << std::endl;
           isFirst = false;
           continue;
       }
   
       // do something with remaining elements
       std::cout << "Remaining element: " << elem << std::endl;
   }
   

Вывод для обоих показанных подходов:

Первый элемент: 1
Оставшийся элемент: 2
Оставшийся элемент: 3

Код на Wandbox