사용자 정의 반복자와 const_iterator를 올바르게 구현하는 방법은 무엇입니까?

iteratorand const_iterator클래스 를 작성하려는 사용자 정의 컨테이너 클래스가 있습니다.

나는 전에 이것을 한 적이 없으며 적절한 방법을 찾지 못했습니다. 반복자 생성에 관한 지침은 무엇이며 무엇을 알고 있어야합니까?

또한 피하기 코드 중복을 같은 (나는 것을 느낄 것 const_iterator하고 iterator, 하나가 다른 서브 클래스해야 공유 많은 것들?).

각주 : Boost는 이것을 쉽게 할 수있는 것이 확실하지만 많은 어리석은 이유로 여기에서는 사용할 수 없습니다.

• 컨테이너에 맞는 반복기 유형 (입력, 출력, 전달 등)을 선택하십시오.
• 표준 라이브러리에서 기본 반복기 클래스를 사용하십시오. 예를 들어, std::iterator함께 random_access_iterator_tag.These 기본 클래스는 STL에서 요구하는 모든 유형 정의를 정의하고 다른 작업을한다.

• 코드 중복을 피하기 위해 반복자 클래스는 템플릿 클래스 여야하며 "값 유형", "포인터 유형", "참조 유형"또는 이들 모두에 의해 매개 변수화되어야합니다 (구현에 따라 다름). 예를 들면 다음과 같습니다.

  // iterator class is parametrized by pointer type
  template <typename PointerType> class MyIterator {
      // iterator class definition goes here
  };
  
  typedef MyIterator<int*> iterator_type;
  typedef MyIterator<const int*> const_iterator_type;
  

  주의 사항 iterator_type및 const_iterator_type유형 정의 : 비 const 및 const 반복자에 대한 유형입니다.

참조 : 표준 라이브러리 참조

편집 : std::iterator C ++ 17부터 더 이상 사용되지 않습니다. 여기 에서 관련 토론을 참조 하십시오 .

커스텀 컨테이너에 대한 반복자를 쉽게 정의하는 방법을 보여 주려고하지만, 컨테이너 유형에 상관없이 커스텀 반복자를 사용하여 커스텀 반복기를 쉽게 만들 수있는 c ++ 11 라이브러리를 만든 경우 인접하지 않습니다.

Github에서 찾을 수 있습니다

다음은 사용자 정의 반복자를 작성하고 사용하는 간단한 단계입니다.

1. "custom iterator"클래스를 작성하십시오.
2. "custom container"클래스에서 typedef를 정의하십시오.
   • 예 : typedef blRawIterator< Type > iterator;
   • 예 : typedef blRawIterator< const Type > const_iterator;
3. "시작"및 "종료"기능 정의
   • 예 : iterator begin(){return iterator(&m_data[0]);};
   • 예 : const_iterator cbegin()const{return const_iterator(&m_data[0]);};
4. 우리는 끝났어 !!!

마지막으로, 커스텀 반복자 클래스를 정의 할 때 :

참고 : 사용자 정의 반복자를 정의 할 때 표준 반복자 범주에서 파생되어 STL 알고리즘이 만든 반복자의 유형을 알립니다.

이 예에서는 랜덤 액세스 반복자와 역방향 랜덤 액세스 반복자를 정의합니다.

1. //-------------------------------------------------------------------
   // Raw iterator with random access
   //-------------------------------------------------------------------
   template<typename blDataType>
   class blRawIterator
   {
   public:
   
       using iterator_category = std::random_access_iterator_tag;
       using value_type = blDataType;
       using difference_type = std::ptrdiff_t;
       using pointer = blDataType*;
       using reference = blDataType&;
   
   public:
   
       blRawIterator(blDataType* ptr = nullptr){m_ptr = ptr;}
       blRawIterator(const blRawIterator<blDataType>& rawIterator) = default;
       ~blRawIterator(){}
   
       blRawIterator<blDataType>&                  operator=(const blRawIterator<blDataType>& rawIterator) = default;
       blRawIterator<blDataType>&                  operator=(blDataType* ptr){m_ptr = ptr;return (*this);}
   
       operator                                    bool()const
       {
           if(m_ptr)
               return true;
           else
               return false;
       }
   
       bool                                        operator==(const blRawIterator<blDataType>& rawIterator)const{return (m_ptr == rawIterator.getConstPtr());}
       bool                                        operator!=(const blRawIterator<blDataType>& rawIterator)const{return (m_ptr != rawIterator.getConstPtr());}
   
       blRawIterator<blDataType>&                  operator+=(const difference_type& movement){m_ptr += movement;return (*this);}
       blRawIterator<blDataType>&                  operator-=(const difference_type& movement){m_ptr -= movement;return (*this);}
       blRawIterator<blDataType>&                  operator++(){++m_ptr;return (*this);}
       blRawIterator<blDataType>&                  operator--(){--m_ptr;return (*this);}
       blRawIterator<blDataType>                   operator++(int){auto temp(*this);++m_ptr;return temp;}
       blRawIterator<blDataType>                   operator--(int){auto temp(*this);--m_ptr;return temp;}
       blRawIterator<blDataType>                   operator+(const difference_type& movement){auto oldPtr = m_ptr;m_ptr+=movement;auto temp(*this);m_ptr = oldPtr;return temp;}
       blRawIterator<blDataType>                   operator-(const difference_type& movement){auto oldPtr = m_ptr;m_ptr-=movement;auto temp(*this);m_ptr = oldPtr;return temp;}
   
       difference_type                             operator-(const blRawIterator<blDataType>& rawIterator){return std::distance(rawIterator.getPtr(),this->getPtr());}
   
       blDataType&                                 operator*(){return *m_ptr;}
       const blDataType&                           operator*()const{return *m_ptr;}
       blDataType*                                 operator->(){return m_ptr;}
   
       blDataType*                                 getPtr()const{return m_ptr;}
       const blDataType*                           getConstPtr()const{return m_ptr;}
   
   protected:
   
       blDataType*                                 m_ptr;
   };
   //-------------------------------------------------------------------
   

2. //-------------------------------------------------------------------
   // Raw reverse iterator with random access
   //-------------------------------------------------------------------
   template<typename blDataType>
   class blRawReverseIterator : public blRawIterator<blDataType>
   {
   public:
   
       blRawReverseIterator(blDataType* ptr = nullptr):blRawIterator<blDataType>(ptr){}
       blRawReverseIterator(const blRawIterator<blDataType>& rawIterator){this->m_ptr = rawIterator.getPtr();}
       blRawReverseIterator(const blRawReverseIterator<blDataType>& rawReverseIterator) = default;
       ~blRawReverseIterator(){}
   
       blRawReverseIterator<blDataType>&           operator=(const blRawReverseIterator<blDataType>& rawReverseIterator) = default;
       blRawReverseIterator<blDataType>&           operator=(const blRawIterator<blDataType>& rawIterator){this->m_ptr = rawIterator.getPtr();return (*this);}
       blRawReverseIterator<blDataType>&           operator=(blDataType* ptr){this->setPtr(ptr);return (*this);}
   
       blRawReverseIterator<blDataType>&           operator+=(const difference_type& movement){this->m_ptr -= movement;return (*this);}
       blRawReverseIterator<blDataType>&           operator-=(const difference_type& movement){this->m_ptr += movement;return (*this);}
       blRawReverseIterator<blDataType>&           operator++(){--this->m_ptr;return (*this);}
       blRawReverseIterator<blDataType>&           operator--(){++this->m_ptr;return (*this);}
       blRawReverseIterator<blDataType>            operator++(int){auto temp(*this);--this->m_ptr;return temp;}
       blRawReverseIterator<blDataType>            operator--(int){auto temp(*this);++this->m_ptr;return temp;}
       blRawReverseIterator<blDataType>            operator+(const int& movement){auto oldPtr = this->m_ptr;this->m_ptr-=movement;auto temp(*this);this->m_ptr = oldPtr;return temp;}
       blRawReverseIterator<blDataType>            operator-(const int& movement){auto oldPtr = this->m_ptr;this->m_ptr+=movement;auto temp(*this);this->m_ptr = oldPtr;return temp;}
   
       difference_type                             operator-(const blRawReverseIterator<blDataType>& rawReverseIterator){return std::distance(this->getPtr(),rawReverseIterator.getPtr());}
   
       blRawIterator<blDataType>                   base(){blRawIterator<blDataType> forwardIterator(this->m_ptr); ++forwardIterator; return forwardIterator;}
   };
   //-------------------------------------------------------------------
   

이제 커스텀 컨테이너 클래스의 어딘가에 :

template<typename blDataType>
class blCustomContainer
{
public: // The typedefs

    typedef blRawIterator<blDataType>              iterator;
    typedef blRawIterator<const blDataType>        const_iterator;

    typedef blRawReverseIterator<blDataType>       reverse_iterator;
    typedef blRawReverseIterator<const blDataType> const_reverse_iterator;

                            .
                            .
                            .

public:  // The begin/end functions

    iterator                                       begin(){return iterator(&m_data[0]);}
    iterator                                       end(){return iterator(&m_data[m_size]);}

    const_iterator                                 cbegin(){return const_iterator(&m_data[0]);}
    const_iterator                                 cend(){return const_iterator(&m_data[m_size]);}

    reverse_iterator                               rbegin(){return reverse_iterator(&m_data[m_size - 1]);}
    reverse_iterator                               rend(){return reverse_iterator(&m_data[-1]);}

    const_reverse_iterator                         crbegin(){return const_reverse_iterator(&m_data[m_size - 1]);}
    const_reverse_iterator                         crend(){return const_reverse_iterator(&m_data[-1]);}

                            .
                            .
                            .
    // This is the pointer to the
    // beginning of the data
    // This allows the container
    // to either "view" data owned
    // by other containers or to
    // own its own data
    // You would implement a "create"
    // method for owning the data
    // and a "wrap" method for viewing
    // data owned by other containers

    blDataType*                                    m_data;
};

그들은 종종 다른 방식으로 iterator전환해서는 안된다는 것을 잊어 버립니다 const_iterator. 이를 수행하는 방법은 다음과 같습니다.

template<class T, class Tag = void>
class IntrusiveSlistIterator
   : public std::iterator<std::forward_iterator_tag, T>
{
    typedef SlistNode<Tag> Node;
    Node* node_;

public:
    IntrusiveSlistIterator(Node* node);

    T& operator*() const;
    T* operator->() const;

    IntrusiveSlistIterator& operator++();
    IntrusiveSlistIterator operator++(int);

    friend bool operator==(IntrusiveSlistIterator a, IntrusiveSlistIterator b);
    friend bool operator!=(IntrusiveSlistIterator a, IntrusiveSlistIterator b);

    // one way conversion: iterator -> const_iterator
    operator IntrusiveSlistIterator<T const, Tag>() const;
};

위의 통지에서 IntrusiveSlistIterator<T>로 변환 하는 방법 IntrusiveSlistIterator<T const>. 경우는 T이미 const결코 사용되지 도착이 변환.

Boost에는 도움이 될만한 것이 있습니다 : Boost.Iterator 라이브러리.

보다 정확하게이 페이지는 boost :: iterator_adaptor 입니다.

흥미로운 점은 사용자 정의 유형에 대한 완전한 구현을 처음부터 보여주는 Tutorial Example 입니다.

template <class Value>
class node_iter
  : public boost::iterator_adaptor<
        node_iter<Value>                // Derived
      , Value*                          // Base
      , boost::use_default              // Value
      , boost::forward_traversal_tag    // CategoryOrTraversal
    >
{
 private:
    struct enabler {};  // a private type avoids misuse

 public:
    node_iter()
      : node_iter::iterator_adaptor_(0) {}

    explicit node_iter(Value* p)
      : node_iter::iterator_adaptor_(p) {}

    // iterator convertible to const_iterator, not vice-versa
    template <class OtherValue>
    node_iter(
        node_iter<OtherValue> const& other
      , typename boost::enable_if<
            boost::is_convertible<OtherValue*,Value*>
          , enabler
        >::type = enabler()
    )
      : node_iter::iterator_adaptor_(other.base()) {}

 private:
    friend class boost::iterator_core_access;
    void increment() { this->base_reference() = this->base()->next(); }
};

이미 언급했듯이 요점은 단일 템플릿 구현과 typedef이를 사용하는 것입니다.

Boost에 도움이 될만한 것이 있는지 모르겠습니다.

내가 선호하는 패턴은 간단합니다. value_typeconst 한정 여부에 관계없이 같은 템플릿 인수를 사용하십시오 . 필요한 경우 노드 유형도 있습니다. 그러면 모든 것이 제자리에 들어갑니다.

복사 생성자 및를 포함하여 필요한 모든 것을 매개 변수화 (템플릿 화)해야합니다 operator==. 대부분의 의미는 const올바른 동작을 만듭니다.

template< class ValueType, class NodeType >
struct my_iterator
 : std::iterator< std::bidirectional_iterator_tag, T > {
    ValueType &operator*() { return cur->payload; }

    template< class VT2, class NT2 >
    friend bool operator==
        ( my_iterator const &lhs, my_iterator< VT2, NT2 > const &rhs );

    // etc.

private:
    NodeType *cur;

    friend class my_container;
    my_iterator( NodeType * ); // private constructor for begin, end
};

typedef my_iterator< T, my_node< T > > iterator;
typedef my_iterator< T const, my_node< T > const > const_iterator;

좋은 답변이 많이 있지만 매우 간결하고 사용하기 쉬운 템플릿 헤더를 만들었습니다 .

클래스에 반복자를 추가하려면 7 개의 작은 함수로 반복자의 상태를 나타 내기 위해 작은 클래스 만 작성하면됩니다. 그 중 2 개는 선택 사항입니다.

#include <iostream>
#include <vector>
#include "iterator_tpl.h"

struct myClass {
  std::vector<float> vec;

  // Add some sane typedefs for STL compliance:
  STL_TYPEDEFS(float);

  struct it_state {
    int pos;
    inline void begin(const myClass* ref) { pos = 0; }
    inline void next(const myClass* ref) { ++pos; }
    inline void end(const myClass* ref) { pos = ref->vec.size(); }
    inline float& get(myClass* ref) { return ref->vec[pos]; }
    inline bool cmp(const it_state& s) const { return pos != s.pos; }

    // Optional to allow operator--() and reverse iterators:
    inline void prev(const myClass* ref) { --pos; }
    // Optional to allow `const_iterator`:
    inline const float& get(const myClass* ref) const { return ref->vec[pos]; }
  };
  // Declare typedef ... iterator;, begin() and end() functions:
  SETUP_ITERATORS(myClass, float&, it_state);
  // Declare typedef ... reverse_iterator;, rbegin() and rend() functions:
  SETUP_REVERSE_ITERATORS(myClass, float&, it_state);
};

그런 다음 STL 반복자에서 예상 한대로 사용할 수 있습니다.

int main() {
  myClass c1;
  c1.vec.push_back(1.0);
  c1.vec.push_back(2.0);
  c1.vec.push_back(3.0);

  std::cout << "iterator:" << std::endl;
  for (float& val : c1) {
    std::cout << val << " "; // 1.0 2.0 3.0
  }

  std::cout << "reverse iterator:" << std::endl;
  for (auto it = c1.rbegin(); it != c1.rend(); ++it) {
    std::cout << *it << " "; // 3.0 2.0 1.0
  }
}

도움이 되길 바랍니다.