C++自定义可对称双向迭代器

#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 VisualIteratorT other) const { return m_node - other.operator-(); } protected: pointer m_node; size_t m_size; }; template typename T using VisualIteratorSp typename std::shared_ptrVisualIteratorT; template typename T class ForwardVisualIterator : public VisualIteratorT { public: using reference typename VisualIteratorT::reference; using pointer typename VisualIteratorT::pointer; constexpr explicit ForwardVisualIterator(T* ptr, size_t size) : VisualIteratorT(ptr, size) {} constexpr reference operator() override { VisualIteratorT::m_node; return *VisualIteratorT::m_node; } constexpr pointer operator(int size) override { pointer tmp VisualIteratorT::m_node; tmp size; return tmp; } constexpr reference operator--() override { --VisualIteratorT::m_node; return *VisualIteratorT::m_node; } constexpr pointer operator--(int size) override { pointer tmp VisualIteratorT::m_node; tmp - size; return tmp; } }; template typename T class ReverseVisualIterator : public VisualIteratorT { public: using reference typename VisualIteratorT::reference; using pointer typename VisualIteratorT::pointer; constexpr explicit ReverseVisualIterator(T* ptr, size_t size) : VisualIteratorT(ptr, size) {} constexpr reference operator() override { --VisualIteratorT::m_node; return *VisualIteratorT::m_node; } constexpr pointer operator(int size) override { pointer tmp VisualIteratorT::m_node; tmp - size; return tmp; } constexpr reference operator--() override { VisualIteratorT::m_node; return *VisualIteratorT::m_node; } constexpr pointer operator--(int size) override { pointer tmp VisualIteratorT::m_node; tmp size; return tmp; } }; /* template typename T, template typename class VT VisualIteratorSpT makeVisualIterator(T *ptr, size_t size, bool bBegin) { assert(false); } */ template typename T VisualIteratorSpT makeVisualIteratorForward(T* ptr, size_t size, bool bBegin) { return std::make_sharedForwardVisualIteratorT((bBegin ? ptr : ptr size), size); } template typename T VisualIteratorSpT makeVisualIteratorBack(T* ptr, size_t size, bool bBegin) { return std::make_sharedReverseVisualIteratorT((bBegin ? ptr size - 1 : ptr - 1), size); } template typename T class BidiVisualIterator { public: using self T; using reference self; using pointer self*; using BaseVisualIter VisualIteratorSpT; constexpr explicit BidiVisualIterator(T* ptr, size_t size, bool dir, bool bBegin) : m_ltr(dir) , m_iter(dir ? makeVisualIteratorForwardT(ptr, size, bBegin) : makeVisualIteratorBackT(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 BidiVisualIteratorT other) const { return m_ltr other.m_ltr operator-() other.operator-(); } constexpr bool operator!(const BidiVisualIteratorT other) const { return !operator(other); } constexpr size_t operator-(const BidiVisualIteratorT 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 VisualIteratorT { public: using reference typename VisualIteratorT::reference; using pointer typename VisualIteratorT::pointer; using cpointer const typename VisualIteratorT::self*; using pointerRef typename VisualIteratorT::self*; constexpr explicit BidiVisualSpan(const T* ptr, const BidiRange range) : VisualIteratorT(const_castT*(ptr), range.size()) , m_bidiRange(range) { } constexpr BidiVisualIteratorT begin() const { return BidiVisualIteratorT(VisualIteratorT::operator-(), VisualIteratorT::size(), isForward(), true); } constexpr BidiVisualIteratorT end() const { return BidiVisualIteratorT(VisualIteratorT::operator-(), VisualIteratorT::size(), isForward(), false); } constexpr BidiVisualIteratorT rbegin() const { return BidiVisualIteratorT(VisualIteratorT::operator-(), VisualIteratorT::size(), !isForward(), true); } constexpr BidiVisualIteratorT rend() const { return BidiVisualIteratorT(VisualIteratorT::operator-(), VisualIteratorT::size(), !isForward(), false); } constexpr BidiVisualIteratorT last() const { BidiVisualIteratorT tmp this-end(); --tmp; return tmp; } constexpr pointer operator[](int i) const { BidiVisualIteratorT tmp this-begin(); auto newNode tmp.operator(i); return newNode; } constexpr reference operator() { VisualIteratorT* base this; return base- operator*(); } constexpr pointer operator(int) { VisualIteratorT* base this; return base- operator-(); } constexpr reference operator--() { VisualIteratorT* base this; return base- operator*(); } constexpr pointer operator--(int) { VisualIteratorT* 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_castT*(isForward() ? data : --data); } constexpr cpointer dec(pointerRef data) const { return const_castT*(isForward() ? --data : data); } constexpr BidiVisualIteratorT inc(const BidiVisualIteratorT data) const { auto tmp data; tmp; return tmp; } constexpr BidiVisualIteratorT dec(const BidiVisualIteratorT data) const { auto tmp data; --tmp; return tmp; } private: BidiRange m_bidiRange; }; /** * brief 双向迭代器测试 * return 支持正反序迭代 */ bool testVisualSpan() { std::vectorint vcts{ 0, 1, 2, 3, 4, 5 }; std::vectorint expectVct; // int * start vcts[0]; BidiVisualSpanint 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(); BidiVisualSpanint 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创作不易小小的支持一下吧