Существует ли стандартный циклический итератор в С++
Исходя из следующего вопроса: Проверьте, является ли одна строка вращением другой строки
Я думал о создании циклического типа итератора, который принимает диапазон, и мог бы решить вышеупомянутую проблему следующим образом:
std::string s1 = "abc" ;
std::string s2 = "bca" ;
std::size_t n = 2; // number of cycles
cyclic_iterator it(s2.begin(),s2.end(),n);
cyclic_iterator end;
if (std::search(it, end, s1.begin(),s1.end()) != end)
{
std::cout << "s1 is a rotation of s2" << std::endl;
}
Мой вопрос: Есть ли что-то подобное? Я проверил Boost и STL и не имел точной реализации.
У меня есть простая рукописная (производная от std::forward_iterator_tag специализированная версия std::iterator), но лучше использовать уже выполненную/протестированную реализацию.
Ответы
Ответ 1
В стандарте нет ничего подобного. Циклы не очень хорошо работают с итераторами С++, потому что последовательность, представляющая весь цикл, имела бы first == last и, следовательно, была бы пустой последовательностью.
Возможно, вы могли бы ввести какое-то состояние в итератор, логический флаг для представления "еще не сделано". Флаг участвует в сравнении. Установите его true перед повторением и false с шагом/уменьшением.
Но лучше всего вручную написать нужные вам алгоритмы. Как только вам удалось представить весь цикл, представляющая пустую последовательность, возможно, стала невозможной.
EDIT: Теперь я замечаю, что вы указали количество циклов. Это имеет большое значение.
template< class I >
class cyclic_iterator
/* : public iterator< bidirectional, yadda yadda > */ {
I it, beg, end;
int cnt;
cyclic_iterator( int c, I f, I l )
: it( f ), beg( f ), end( l ), cnt( c ) {}
public:
cyclic_iterator() : it(), beg(), end(), cnt() {}
cyclic_iterator &operator++() {
++ it;
if ( it == end ) {
++ cnt;
it = beg;
}
} // etc for --, post-operations
friend bool operator==
( cyclic_iterator const &lhs, cyclic_iterator const &rhs )
{ return lhs.it == rhs.it && lhs.cnt == rhs.cnt; } // etc for !=
friend pair< cyclic_iterator, cyclic_iterator > cycle_range
( int c, I f, I l ) {//factory function, better style outside this scope
return make_pair( cyclic_iterator( 0, f, l ),
cyclic_iterator( c, f, l ) );
}
};
Ответ 2
Это должно предоставить некоторые идеи/решения: 2 исполнения, второе немного легче по весу. Оба тестируются с использованием поддиапазона вектора и списка...
#include <vector>
template <typename T, typename Container = std::vector<T>, typename Iterator = Container::iterator>
class RingIterator : public std::iterator <std::bidirectional_iterator_tag, T, ptrdiff_t>
{
Container& data;
Iterator cursor;
Iterator begin;
Iterator end;
public:
RingIterator (Container& v) : data(v), cursor(v.begin()), begin(v.begin()), end(v.end()) {}
RingIterator (Container& v, const Iterator& i) : data(v), cursor(i), begin(v.begin()), end(v.end()) {}
RingIterator (Container& v, const Iterator& i, const Iterator& j) : data(v), cursor(i), begin(i), end(j) {}
RingIterator (Container& v, size_t i) : data(v), cursor(v.begin() + i % v.size()), begin(v.begin()), end(v.end()) {}
bool operator == (const RingIterator& x) const
{
return cursor == x.cursor;
}
bool operator != (const RingIterator& x) const
{
return ! (*this == x);
}
reference operator*() const
{
return *cursor;
}
RingIterator& operator++()
{
++cursor;
if (cursor == end)
cursor = begin;
return *this;
}
RingIterator operator++(int)
{
RingIterator ring = *this;
++*this;
return ring;
}
RingIterator& operator--()
{
if (cursor == begin)
cursor = end;
--cursor;
return *this;
}
RingIterator operator--(int)
{
RingIterator ring = *this;
--*this;
return ring;
}
RingIterator insert (const T& x)
{
return RingIterator (data, data.insert (cursor, x));
}
RingIterator erase()
{
return RingIterator (data, data.erase (cursor));
}
};
template <typename T, typename Iterator>
class CyclicIterator : public std::iterator <std::bidirectional_iterator_tag, T, ptrdiff_t>
{
Iterator cursor;
Iterator begin;
Iterator end;
public:
CyclicIterator (const Iterator& i, const Iterator& j) : cursor(i), begin(i), end(j) {}
bool operator == (const CyclicIterator& x) const
{
return cursor == x.cursor;
}
bool operator != (const CyclicIterator& x) const
{
return ! (*this == x);
}
reference operator*() const
{
return *cursor;
}
CyclicIterator& operator++()
{
++cursor;
if (cursor == end)
cursor = begin;
return *this;
}
CyclicIterator operator++(int)
{
CyclicIterator ring = *this;
++*this;
return ring;
}
CyclicIterator& operator--()
{
if (cursor == begin)
cursor = end;
--cursor;
return *this;
}
CyclicIterator operator--(int)
{
CyclicIterator ring = *this;
--*this;
return ring;
}
};
#include <iostream>
#include <iomanip>
#include <list>
enum { CycleSize = 9, ContainerSize };
template <typename cyclicIterator>
void test (cyclicIterator& iterator, size_t mn)
{
int m = mn;
while (m--)
for (int n = mn; n--; ++iterator)
std::cout << std::setw(3) << *iterator << ' ';
--iterator;
m = mn;
while (m--)
for (int n = mn; n--; --iterator)
std::cout << std::setw(3) << *iterator << ' ';
}
template <typename containers>
void load (containers& container)
{
while (container.size() < ContainerSize)
container.push_back (container.size());
}
void main (void)
{
typedef std::vector<int> vContainer;
typedef vContainer::iterator vIterator;
typedef std::list<int> lContainer;
typedef lContainer::iterator lIterator;
vContainer v; load (v);
vIterator vbegin = v.begin() + 1;
RingIterator <int, vContainer, vIterator> vring (v, vbegin, v.end());
CyclicIterator <int, vIterator> vcycle (vbegin, v.end());
lContainer l; load (l);
lIterator lbegin = l.begin(); ++lbegin;
RingIterator <int, lContainer, lIterator> lring (l, lbegin, l.end());
CyclicIterator <int, lIterator> lcycle (lbegin, l.end());
test (vring, CycleSize);
test (vcycle, CycleSize);
test (lring, CycleSize);
test (lcycle, CycleSize);
}
Ответ 3
Библиотека CGAL определяет Циркуляторы. Они используются так.
template <class Circulator, class T>
bool contains( Circulator c, Circulator d, const T& value) {
if (c != 0) {
do {
if (*c == value)
return true;
} while (++c != d);
}
return false;
}
Обратите внимание, что они выглядят как итераторы с первого взгляда, но обратите внимание, что логика (и структура цикла) отличается от итераторов). 'if (not empty) do {..} while() instead of while() {...} `.
Ответ 4
Возможно, вы ищете Boosts Круговой буфер. Но если вы уже проверили Boost, это может быть не тот, который вам нужен.
Ответ 5
С другой стороны, сама идея циклического итератора несовместима с идеей контейнера STL. Вы не должны использовать циклический итератор, так как пользователь этого итератора может быть удивлен своим необычным поведением. Обычно в STL вы выполняете итерацию от начала до конца контейнера. Бесконечная петля в этом случае. Потому что конец недоступен.
В конце концов, очевидно, что вы не собираетесь выполнять более двух циклов для решения своей задачи. Нет причин иметь специальный итератор с запутанным поведением. Лучше повторить обычный линейный контейнер дважды или может быть еще меньше, чем дважды.
