雙向迭代器實現

Question

由於某些原因，我需要實現一個雙向迭代器，一段時間后，我得到了這個結果（ add參數告訴迭代器應該移動到哪一側（在實現reverse_iterator時避免代碼重復））：

#include <iterator>

namespace gph {
    template <typename T, int add> class BidirectionalIterator;

    template<typename T, int add>
    void swap(BidirectionalIterator<T, add>& it1, BidirectionalIterator<T, add>& it2) {
        it1.swap(it2);
    }

    template<typename T, int add>
    class BidirectionalIterator {
    private:
        T *currentPosition, *begin, *end;
    public:
        using difference_type = std::ptrdiff_t;
        using value_type = T;
        using pointer = T*;
        using reference = T&;
        using iterator_category = std::bidirectional_iterator_tag;

        inline BidirectionalIterator(T* currentPosition, T* begin, T* end):currentPosition(currentPosition), begin(begin), end(end) {}

        //copy constructor
        inline BidirectionalIterator(const BidirectionalIterator& iterator)
            :BidirectionalIterator(iterator.currentPosition, iterator.begin, iterator.end) {}

        //move constructor
        inline BidirectionalIterator(BidirectionalIterator&& iterator) noexcept
            :BidirectionalIterator(iterator.currentPosition, iterator.begin, iterator.end) {}

        //copy and move assignment statement
        inline BidirectionalIterator& operator=(BidirectionalIterator iterator) {
           gph::swap(*this, iterator);
        }

        inline void swap(BidirectionalIterator& iterator) {
            std::swap(currentPosition, iterator.currentPosition);
            std::swap(begin, iterator.begin);
            std::swap(end, iterator.end);
        }

        inline reference operator*() const {
            return *currentPosition; //dangerous if the iterator is in not-dereferenceable state
        }

        inline BidirectionalIterator& operator++() {
            if (currentPosition != end) currentPosition += add;

            return *this;
        }

        inline bool operator==(const BidirectionalIterator& iterator) const {
            return currentPosition == iterator.currentPosition;
        }

        inline bool operator!=(const BidirectionalIterator& iterator) const {
            return !(*this == iterator);
        }

        inline BidirectionalIterator operator++(int) {
            BidirectionalIterator past = *this;

            ++*this;

            return past;
        }

        inline BidirectionalIterator& operator--() {
            if (currentPosition != begin) currentPosition -= add;

            return *this;
        }

        inline BidirectionalIterator operator--(int) {
            BidirectionalIterator past = *this;

            --*this;

            return past;
        }
    };
}

我試圖滿足MoveAssignable 、 MoveConstructible 、 CopyAssignable 、 CopyConstructible 、 Swappable 、 EqualityComparable 、 LegacyIterator 、 LegacyInputIterator 、 LegacyForwardIterator 、 LegacyBidirectionalIterator命名要求。

他們的一些要求以運算符重載表示，但其中一些我不知道如何實現（也許它們是由其他人自動實現的？），例如： i->m或*i++ （來自這里）。 第一個問題：我應該如何實現它們？

第二個問題：我的迭代器實現好嗎？ 它的缺點是什么，我在哪里犯了錯誤？

PS這些問題處於非建設性的邊緣，但我真的需要幫助。 對不起我的英語不好。

Answer 1

我發現很難找到一個明確的答案，所以只是一些想法，可能不完整，可以討論。

• i->m可以通過inline pointer operator->() { return this->currentPosition; }來實現inline pointer operator->() { return this->currentPosition; }
• *i++應該已經包含在您的實現中

• 我看不出有任何理由交換operator=中的所有指針。 出於三個原因：

  1. 您正在用局部變量交換值
  2. 移動構造函數不交換任何值（ BidirectionalIterator newIt=oldIt;和BidirectionalIterator newIt(oldIt);之間的行為不一致，但實際上不是因為前一點）
  3. 那些指針不是唯一資源，所以復制它們並在多個實例之間共享它們是沒有問題的
• operator=缺少return 。
• 您using difference_type = std::ptrdiff_t; 但是不要實現operator-這將返回difference_type ，為什么不實現呢？
• 反向迭代器可以通過std::reverse_iterator更容易地實現，它只會包裝你的迭代器並反轉 ++ 和 -- 等等。
• 您可能希望找到一種簡單的方法來實現迭代器的 const 版本（始終返回const T&或const T*的版本）。 我看到了這個的三個版本：
  • 復制所有代碼
  • 使用常量轉換
  • 使用額外的模板參數bool TIsConst並using pointer = std::conditional_t<TIsConst, const T*, T*>;
  • 另一方面，使用帶有參數const T的模板化迭代器可能看起來很容易，但無法滿足要求， 請參閱此問題