Объединение в цепочку итераторов для C++

В C ++ итератор обычно не имеет смысла вне контекста начала и конца диапазона. Сам итератор не знает, где находится начало и конец. Поэтому для того, чтобы сделать что-то подобное, вам нужно вместо этого объединить в цепочку диапазоны итераторов - диапазон - это пара итераторов (начало, конец).

См. Документацию boost :: range . Он может предоставлять инструменты для построения цепочки диапазонов. Единственное отличие состоит в том, что они должны быть одного типа и возвращать один и тот же тип итератора. Кроме того, может быть возможно сделать этот дополнительный общий для объединения различных типов диапазонов с чем-то вроде any_iterator, но, возможно, и нет.

Я уже писал один раньше (на самом деле, просто для того, чтобы связать две пары итераторов вместе). Это не так уж сложно, особенно если вы используете boost iterator_facade .

Создание итератора ввода (что, по сути, делает цепочка в Python) - простой первый шаг. Поиск правильной категории для итератора, объединяющего комбинацию различных категорий итераторов, оставлен в качестве упражнения для читателя; -).

Нет в стандартной библиотеке. Boost может что-то иметь.

Но на самом деле такая вещь должна быть тривиальной для реализации. Просто сделайте себе итератор с вектором итераторов в качестве члена. Какой-то очень простой код для оператора ++, и вот вы.

Проверьте Библиотеку шаблонов представлений (VTL) . Он может не предоставлять напрямую «цепной итератор». Но я думаю, что в нем есть все необходимые инструменты / шаблоны для реализации вашего собственного «цепного итератора».

Со страницы VTL:

Представление - это адаптер контейнера, который предоставляет интерфейс контейнера для

1. частей данных или
2. реорганизации данных или
3. преобразованных данных или
4. подходящая комбинация наборов данных

базового контейнера (ов). Поскольку представления сами по себе предоставляют интерфейс контейнера, их можно легко комбинировать и складывать. Из-за уловки шаблонов представления могут адаптировать свой интерфейс к базовым контейнерам. Более изощренная хитрость шаблонов делает эту мощную функцию простой в использовании.

По сравнению с умными итераторами, представления - это просто фабрики умных итераторов.

Насколько мне известно, в Boost нет функциональности, реализующей это - я провел довольно обширный поиск.

Я думал, что легко это реализовал на прошлой неделе, но я побежал в загвоздку: STL, поставляемый с Visual Studio 2008, когда включена проверка диапазона, не позволяет сравнивать итераторы из разных контейнеров (т.е. вы не можете сравнивать somevec1.end () с somevec2.end ()). Внезапно реализовать это стало намного сложнее, и я еще не совсем решил, как это сделать.

В прошлом я писал другие итераторы, используя iterator_facade и iterator_adapter из boost, что лучше, чем писать 'raw' итераторы, но я все еще считаю написание собственных итераторов на C ++ довольно беспорядочным.

По сути, вы ищете итератор фасада, который абстрагирует обход нескольких последовательностей.

Поскольку вы пришли из среды Python, я предполагаю, что вас больше заботит гибкость а не скорость. Под гибкостью я подразумеваю способность последовательно перебирать различные типы последовательностей вместе (вектор, массив, связанный список, набор и т. Д.), А под скоростью я имею в виду только выделение памяти из стека.

Если это так, тогда вы можете посмотреть any_iterator из Adobe labs: http://stlab.adobe.com/classadobe_1_1any__iterator.html

Этот итератор дает вам возможность перебирать любой тип последовательности во время выполнения. Чтобы связать, у вас будет вектор (или массив) из трех кортежей any_iterators, то есть три any_iterator для каждого диапазона, который вы объединяете вместе (вам нужно три для итерации вперед или назад, если вы просто хотите итерацию вперед, двух будет достаточно).

Допустим, вы хотите последовательно перебрать последовательность целых чисел:

(Непроверенный код псевдо-c ++)

typedef adobe :: any_iterator AnyIntIter;

struct AnyRange { AnyIntIter begin; AnyIntIter curr; AnyIntIter end; };

Вы можете определить диапазон, например:

int int_array [] = {1, 2, 3, 4}; AnyRange sequence_0 = {int_array, int_array, int_array + ARRAYSIZE (int_array)};

Тогда ваш класс RangeIterator будет иметь std :: vector.

<code>
class RangeIterator {
 public:
  RangeIterator() : curr_range_index(0) {}

  template <typename Container>
  void AddAnyRange(Container& c) {
    AnyRange any_range = { c.begin(), c.begin(), c.end() };
    ranges.push_back(any_range);
  }

  // Here's what the operator++() looks like, everything else omitted.
  int operator++() {

     while (true) {
       if (curr_range_index > ranges.size()) {
         assert(false, "iterated too far");
         return 0;
       }
       AnyRange* any_range = ranges[curr_range_index];
       if (curr_range->curr != curr_range->end()) {
         ++(curr_range->curr);
         return *(curr_range->curr);
       }
       ++curr_range_index;      
     }
  }


 private:
  std::vector<AnyRange> ranges;
  int curr_range_index; 
};
</code>

Однако я хочу отметить, что это решение очень медленное. Более лучший, более похожий на C ++ подход - просто хранить все указатели на объекты, с которыми вы хотите работать, и перебирать их. В качестве альтернативы вы можете применить к своим диапазонам функтор или посетителя.