基于以下问题：Check if one string is a rotation of other string
我正在考虑制作一个带有范围的循环迭代器类型，并且能够像这样解决上述问题：
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的专用版本）但我宁愿使用已经制作/测试的实现。
答案 0 :(得分：11)
标准中没有这样的内容。循环与C ++迭代器不兼容，因为表示整个循环的序列将具有first == last，因此是空序列。
可能你可以在迭代器中引入一些状态，这是一个表示“尚未完成”的布尔标志。国旗参与比较。在迭代之前将其设置为true，在递增/递减时设置为false。
但手动编写所需的算法可能更好。一旦你设法代表整个周期，代表一个空序列可能已经变得不可能了。
编辑：现在我注意到您指定了周期数。这会产生很大的不同。
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 ) );
}
};
答案 1 :(得分：3)
这应该提供一些想法/解决方案：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);
}
答案 2 :(得分：2)
CGAL库定义Circulators。它们就像这样使用。
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()代替while(){...}。
答案 3 :(得分：0)
你可能正在寻找Boost的Circular Buffer。但是如果你已经检查过Boost，它可能不是你想要的那个。
答案 4 :(得分：0)
另一方面，循环迭代器的想法与STL容器意识形态不兼容。你不应该想要循环迭代器，因为这个迭代器的用户可能会因其不寻常的行为而感到惊讶。通常在STL中，您从容器的开头到结尾进行迭代。在这种情况下无限循环。因为无法到达终点。
毕竟，显然，你不会做超过2个周期来解决你的任务。没有理由让具有混乱行为的特殊迭代器。最好迭代通常的线性容器两次，或者甚至可能少于两次。
答案 5 :(得分：0)
Eric Niebler的ranges-v3库（即将推出的C++20 ranges所基于的库）具有ranges::view::cycle。这会将其源范围调整为无限重复的无限范围。但是，我们需要进行一次重复，使用ranges::view::concat可以轻松实现。
<div class="parent-container">
<div class="child-one"></div>
<div class="child-two"></div>
<div class="child-three"></div>
</div>