Wie implementiere ich benutzerdefinierte Iteratoren und const_iterators korrekt?

Ich habe eine benutzerdefinierte Containerklasse, für die ich die Klassen iteratorund schreiben möchte const_iterator.

Ich habe das noch nie gemacht und keine passende Anleitung gefunden. Was sind die Richtlinien für die Erstellung von Iteratoren und worauf sollte ich achten?

Ich möchte auch Code-Duplikate vermeiden (ich fühle das const_iteratorund iteratorteile viele Dinge; sollte eine Unterklasse die andere sein?).

Fußnote: Ich bin mir ziemlich sicher, dass Boost etwas hat, um dies zu erleichtern, aber ich kann es hier aus vielen dummen Gründen nicht verwenden.

• Wählen Sie den Typ Ihres Iterators, der zu Ihrem Container passt: Eingabe, Ausgabe, Weiterleitung usw.
• Verwenden Sie Basisiteratorklassen aus der Standardbibliothek. Zum Beispiel std::iteratormit random_access_iterator_tag.Diese Basisklassen alle Typdefinitionen von STL erforderlich definieren und anderer Arbeit verrichten.

• Um eine Codeduplizierung zu vermeiden, sollte die Iteratorklasse eine Vorlagenklasse sein und durch "Werttyp", "Zeigertyp", "Referenztyp" oder alle (abhängig von der Implementierung) parametrisiert werden. Beispielsweise:

  // 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;

  Hinweis- iterator_typeund const_iterator_typeTypdefinitionen: Dies sind Typen für Ihre Nicht-Konstanten- und Konstanten-Iteratoren.

Siehe auch: Standardbibliotheksreferenz

BEARBEITEN: std::iterator ist seit C ++ 17 veraltet. Eine entsprechende Diskussion finden Sie hier .

Ich werde Ihnen zeigen, wie Sie Iteratoren für Ihre benutzerdefinierten Container einfach definieren können, aber nur für den Fall, dass ich eine C ++ 11-Bibliothek erstellt habe, mit der Sie problemlos benutzerdefinierte Iteratoren mit benutzerdefiniertem Verhalten für jeden Containertyp erstellen können, unabhängig davon nicht zusammenhängend.

Sie finden es auf Github

Hier sind die einfachen Schritte zum Erstellen und Verwenden von benutzerdefinierten Iteratoren:

1. Erstellen Sie Ihre "benutzerdefinierte Iterator" -Klasse.
2. Definieren Sie typedefs in Ihrer Klasse "Benutzerdefinierter Container".
   • z.B typedef blRawIterator< Type > iterator;
   • z.B typedef blRawIterator< const Type > const_iterator;
3. Definieren Sie die Funktionen "Anfang" und "Ende"
   • z.B iterator begin(){return iterator(&m_data[0]);};
   • z.B const_iterator cbegin()const{return const_iterator(&m_data[0]);};
4. Wir sind fertig!!!

Schließlich zur Definition unserer benutzerdefinierten Iteratorklassen:

ANMERKUNG: Bei der Definition von benutzerdefinierten Iteratoren leiten wir die Standard-Iteratorkategorien ab, um STL-Algorithmen über den von uns erstellten Iteratortyp zu informieren.

In diesem Beispiel definiere ich einen Iterator mit wahlfreiem Zugriff und einen Iterator mit umgekehrtem wahlfreiem Zugriff:

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;}
   };
   //-------------------------------------------------------------------

Jetzt irgendwo in Ihrer benutzerdefinierten Containerklasse:

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;
};

Sie vergessen oft, dass iteratordas konvertieren muss, const_iteratoraber nicht umgekehrt. Hier ist ein Weg, dies zu tun:

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;
};

In der obigen Anmerkung, wie IntrusiveSlistIterator<T>konvertiert zu IntrusiveSlistIterator<T const>. Wenn dies Tbereits der Fall ist, wird constdiese Konvertierung nie verwendet.

Boost hat etwas zu helfen: die Boost.Iterator-Bibliothek.

Genauer gesagt diese Seite: boost :: iterator_adaptor .

Sehr interessant ist das Tutorial-Beispiel, das eine vollständige Implementierung eines benutzerdefinierten Typs von Grund auf zeigt.

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(); }
};

Der Hauptpunkt ist, wie bereits erwähnt, die Verwendung einer einzelnen Vorlagenimplementierung und typedefdieser.

Ich weiß nicht, ob Boost etwas hat, das helfen würde.

Mein bevorzugtes Muster ist einfach: Nehmen Sie ein Vorlagenargument value_type, das entweder const qualifiziert ist oder nicht. Bei Bedarf auch ein Knotentyp. Dann passt alles zusammen.

Denken Sie daran, alles zu parametrisieren (template-ize), was erforderlich ist, einschließlich des Kopierkonstruktors und operator==. Zum größten Teil erzeugt die Semantik von constkorrektes Verhalten.

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;

Es gibt viele gute Antworten, aber ich habe einen von mir verwendeten Vorlagen-Header erstellt , der sehr präzise und einfach zu verwenden ist.

Um Ihrer Klasse einen Iterator hinzuzufügen, muss nur eine kleine Klasse geschrieben werden, um den Status des Iterators mit 7 kleinen Funktionen darzustellen, von denen 2 optional sind:

#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);
};

Dann können Sie es so verwenden, wie Sie es von einem STL-Iterator erwarten würden:

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
  }
}

Ich hoffe, es hilft.