#include <cassert>
#include <memory>
#include <vector>
#include <iostream>
class Range
{
public:
using Index = uint64_t;
using SignedIndex = int64_t;
using Offset = int64_t;
using Size = uint64_t;
Range() = default;
template <typename T>
Range(T start, T end)
{
if (!isValidRange(start, end)) {
assert(false);
return;
}
m_start = start;
m_end = end;
}
Range(const Range& other) = default;
bool isEmpty() const { return 0 == size(); }
bool isValid() const { return isValidRange(m_start, m_end); }
bool isEqual(const Range& other) const { return m_start == other.m_start && m_end == other.m_end; }
bool contains(SignedIndex pos) const { return pos >= 0 && contains((Index)pos); }
bool contains(Index pos) const { return m_start <= pos && pos < m_end; }
bool contains(const Range& other) const
{
return !other.isEmpty() && m_start <= other.m_start && other.m_end <= m_end;
}
Size size() const { return isValid() ? m_end - m_start : 0; }
Index begin() const { return m_start; }
Index start() const { return m_start; }
Index end() const { return m_end; }
Index last() const { return isEmpty() ? m_start : m_end - 1; }
void setSize(Size newSize) { m_end = m_start + newSize; }
bool operator==(const Range& other) const { return isEqual(other); }
bool operator!=(const Range& other) const { return !isEqual(other); }
friend std::ostream& operator<<(std::ostream& os, const Range& range)
{
os << "[" << range.m_start << "," << range.m_end << ")";
return os;
}
protected:
template <typename T>
static bool isValidRange(T start, T end)
{
return start >= 0 && end >= start;
}
private:
Index m_start = 0;
Index m_end = 0;
};
class BidiRange : public Range
{
public:
BidiRange::BidiRange(const Range& range, bool bForward) : Range(range), m_bForward(bForward) {}
[[nodiscard]] bool BidiRange::isForward() const
{
return m_bForward;
}
private:
bool m_bForward;
};
template <typename T>
class VisualIterator
{
public:
using self = T;
using reference = self&;
using pointer = self*;
constexpr explicit VisualIterator(T* ptr, size_t size) : m_node(ptr), m_size(size) {}
constexpr reference operator*() const { return *m_node; }
constexpr pointer operator->() const { return m_node; }
constexpr virtual reference operator++() = 0;
constexpr virtual pointer operator++(int size) = 0;
constexpr virtual reference operator--() = 0;
constexpr virtual pointer operator--(int size) = 0;
[[nodiscard]] constexpr size_t size() const { return m_size; }
constexpr size_t operator-(const VisualIterator<T>& other) const { return m_node - other.operator->(); }
protected:
pointer m_node;
size_t m_size;
};
template <typename T>
using VisualIteratorSp = typename std::shared_ptr<VisualIterator<T>>;
template <typename T>
class ForwardVisualIterator : public VisualIterator<T>
{
public:
using reference = typename VisualIterator<T>::reference;
using pointer = typename VisualIterator<T>::pointer;
constexpr explicit ForwardVisualIterator(T* ptr, size_t size) : VisualIterator<T>(ptr, size) {}
constexpr reference operator++() override
{
++VisualIterator<T>::m_node;
return *VisualIterator<T>::m_node;
}
constexpr pointer operator++(int size) override
{
pointer tmp = VisualIterator<T>::m_node;
tmp += size;
return tmp;
}
constexpr reference operator--() override
{
--VisualIterator<T>::m_node;
return *VisualIterator<T>::m_node;
}
constexpr pointer operator--(int size) override
{
pointer tmp = VisualIterator<T>::m_node;
tmp -= size;
return tmp;
}
};
template <typename T>
class ReverseVisualIterator : public VisualIterator<T>
{
public:
using reference = typename VisualIterator<T>::reference;
using pointer = typename VisualIterator<T>::pointer;
constexpr explicit ReverseVisualIterator(T* ptr, size_t size) : VisualIterator<T>(ptr, size) {}
constexpr reference operator++() override
{
--VisualIterator<T>::m_node;
return *VisualIterator<T>::m_node;
}
constexpr pointer operator++(int size) override
{
pointer tmp = VisualIterator<T>::m_node;
tmp -= size;
return tmp;
}
constexpr reference operator--() override
{
++VisualIterator<T>::m_node;
return *VisualIterator<T>::m_node;
}
constexpr pointer operator--(int size) override
{
pointer tmp = VisualIterator<T>::m_node;
tmp += size;
return tmp;
}
};
/*
template <typename T, template <typename> class VT>
VisualIteratorSp<T> makeVisualIterator(T *ptr, size_t size, bool bBegin)
{
assert(false);
}
*/
template <typename T>
VisualIteratorSp<T> makeVisualIteratorForward(T* ptr, size_t size, bool bBegin)
{
return std::make_shared<ForwardVisualIterator<T>>((bBegin ? ptr : ptr + size), size);
}
template <typename T>
VisualIteratorSp<T> makeVisualIteratorBack(T* ptr, size_t size, bool bBegin)
{
return std::make_shared<ReverseVisualIterator<T>>((bBegin ? ptr + size - 1 : ptr - 1), size);
}
template <typename T>
class BidiVisualIterator
{
public:
using self = T;
using reference = self&;
using pointer = self*;
using BaseVisualIter = VisualIteratorSp<T>;
constexpr explicit BidiVisualIterator(T* ptr, size_t size, bool dir, bool bBegin)
: m_ltr(dir)
, m_iter(dir ? makeVisualIteratorForward<T>(ptr, size, bBegin) : makeVisualIteratorBack<T>(ptr, size, bBegin))
{
}
constexpr reference operator*() const { return m_iter->operator*(); }
constexpr pointer operator->() const { return m_iter->operator->(); }
constexpr reference operator++() { return m_iter->operator++(); }
constexpr pointer operator++(int size) { return m_iter->operator++(size); }
constexpr reference operator--() { return m_iter->operator--(); }
constexpr pointer operator--(int size) { return m_iter->operator--(size); }
constexpr bool operator==(const BidiVisualIterator<T>& other) const
{
return m_ltr == other.m_ltr && operator->() == other.operator->();
}
constexpr bool operator!=(const BidiVisualIterator<T>& other) const { return !operator==(other); }
constexpr size_t operator-(const BidiVisualIterator<T>& other) const
{
return (*m_iter).operator->() - other.operator->();
}
[[nodiscard]] constexpr bool isForward() const { return m_ltr; }
private:
bool m_ltr;
BaseVisualIter m_iter;
};
/*
支持内部双向迭代器rbegin,begin,rend,end
*/
template <typename T>
class BidiVisualSpan : public VisualIterator<T>
{
public:
using reference = typename VisualIterator<T>::reference;
using pointer = typename VisualIterator<T>::pointer;
using cpointer = const typename VisualIterator<T>::self*;
using pointerRef = typename VisualIterator<T>::self*&;
constexpr explicit BidiVisualSpan(const T* ptr, const BidiRange& range)
: VisualIterator<T>(const_cast<T*>(ptr), range.size())
, m_bidiRange(range)
{
}
constexpr BidiVisualIterator<T> begin() const
{
return BidiVisualIterator<T>(VisualIterator<T>::operator->(), VisualIterator<T>::size(), isForward(), true);
}
constexpr BidiVisualIterator<T> end() const
{
return BidiVisualIterator<T>(VisualIterator<T>::operator->(), VisualIterator<T>::size(), isForward(), false);
}
constexpr BidiVisualIterator<T> rbegin() const
{
return BidiVisualIterator<T>(VisualIterator<T>::operator->(), VisualIterator<T>::size(), !isForward(), true);
}
constexpr BidiVisualIterator<T> rend() const
{
return BidiVisualIterator<T>(VisualIterator<T>::operator->(), VisualIterator<T>::size(), !isForward(), false);
}
constexpr BidiVisualIterator<T> last() const
{
BidiVisualIterator<T> tmp = this->end();
--tmp;
return tmp;
}
constexpr pointer operator[](int i) const
{
BidiVisualIterator<T> tmp = this->begin();
auto newNode = tmp.operator++(i);
return newNode;
}
constexpr reference operator++()
{
VisualIterator<T>* base = this;
return base-> operator*();
}
constexpr pointer operator++(int)
{
VisualIterator<T>* base = this;
return base-> operator->();
}
constexpr reference operator--()
{
VisualIterator<T>* base = this;
return base-> operator*();
}
constexpr pointer operator--(int)
{
VisualIterator<T>* base = this;
return base-> operator->();
}
[[nodiscard]] constexpr bool isForward() const { return m_bidiRange.isForward(); }
[[nodiscard]] constexpr const BidiRange& getBidiRange() const { return m_bidiRange; }
constexpr cpointer inc(pointerRef data) const { return const_cast<T*>(isForward() ? ++data : --data); }
constexpr cpointer dec(pointerRef data) const { return const_cast<T*>(isForward() ? --data : ++data); }
constexpr BidiVisualIterator<T> inc(const BidiVisualIterator<T>& data) const
{
auto tmp = data;
++tmp;
return tmp;
}
constexpr BidiVisualIterator<T> dec(const BidiVisualIterator<T>& data) const
{
auto tmp = data;
--tmp;
return tmp;
}
private:
BidiRange m_bidiRange;
};
/**
* @brief 双向迭代器测试
* @return 支持正反序迭代
*/
bool testVisualSpan()
{
std::vector<int> vcts{ 0, 1, 2, 3, 4, 5 };
std::vector<int> expectVct;
// int * start = &vcts[0];
BidiVisualSpan<int> spanVisual(&vcts[0], BidiRange(Range(0, 6), true));
for (auto item = spanVisual.begin(); item != spanVisual.end(); ++item) {
// printf("%d\n", *item);
expectVct.emplace_back(*item);
}
if (expectVct != vcts)
return false;
expectVct.clear();
for (auto item : spanVisual) {
// printf("%d\n", item);
expectVct.emplace_back(item);
}
if (expectVct != vcts)
return false;
expectVct.clear();
for (auto item = spanVisual.rbegin(); item != spanVisual.rend(); ++item) {
// printf("%d\n", *item);
expectVct.emplace_back(*item);
}
std::reverse(expectVct.begin(), expectVct.end());
if (expectVct != vcts)
return false;
expectVct.clear();
BidiVisualSpan<int> spanRVisual(&vcts[0], BidiRange(Range(0, 6), false));
if (spanRVisual.rend() != spanVisual.end())
return false; // 支持双向同源迭代器
if (spanRVisual.rbegin() != spanVisual.begin())
return false; // 支持双向同源迭代器
for (auto item = spanRVisual.begin(); item != spanRVisual.end(); ++item) {
// printf("%d\n", *item);
expectVct.emplace_back(*item);
}
std::reverse(expectVct.begin(), expectVct.end());
if (expectVct != vcts)
return false;
expectVct.clear();
for (auto item : spanRVisual) {
// printf("%d\n", item);
expectVct.emplace_back(item);
}
std::reverse(expectVct.begin(), expectVct.end());
if (expectVct != vcts)
return false;
expectVct.clear();
for (auto item = spanRVisual.rbegin(); item != spanRVisual.rend(); ++item) {
// printf("%d\n", *item);
expectVct.emplace_back(*item);
}
if (expectVct != vcts)
return false;
return true;
}
void test() {
std::cout << (testVisualSpan() ? "Test OK !" : "Test Failed !") << std::endl;
// Test OK !
}对比参考
std::bidirectional_iterator - cppreference.com
创作不易，小小的支持一下吧！
