problèmes d'itérateur

Question

Dans arrayList, je personnalise l'itérateur, puis j'utilise le tri de stl et l'itérateur pour trier la chaîne (mots).

**//arrayList.h** 
template<class T> 
class arrayList { 
public: 
    // constructor, copy constructor and destructor 
    arrayList(int initialCapacity = 10); 
    arrayList(const arrayList<T>&); 
    ~arrayList() { 
     delete[] element; 
    } 

    // ADT methods 
    bool empty() const { 
     return listSize == 0; 
    } 
    int size() const { 
     return listSize; 
    } 
    T& get(int theIndex) const; 
    int indexOf(const T& theElement) const; 
    void erase(int theIndex); 
    void insert(int theIndex, const T& theElement); 
    void output(ostream& out) const; 

    // additional method 
    int capacity() const { 
     return arrayLength; 
    } 
    void reverse(); 

    // iterators to start and end of list 
    class Pointer; 
    Pointer begin() { 
     return Pointer(element); 
    } 
    Pointer end() { 
     return Pointer(element + listSize); 
    } 

    // iterator for arrayList 
      class iterator 
      { 
      public: 
       // typedefs required by C++ for a bidirectional iterator 
       typedef bidirectional_iterator_tag iterator_category; 
       typedef T value_type; 
       typedef ptrdiff_t difference_type; 
       typedef T* pointer; 
       typedef T& reference; 

       // constructor 
       iterator(T* thePosition = 0) {position = thePosition;} 

       // dereferencing operators 
       T& operator*() const {return *position;} 
       T* operator->() const {return position;} 

       // increment 
       iterator& operator++() // preincrement 
          {++position; return *this;} 
       iterator operator++(int) // postincrement 
          {iterator old = *this; 
          ++position; 
          return old; 
          } 

       // decrement 
       iterator& operator--() // predecrement 
          {--position; return *this;} 
       iterator operator--(int) // postdecrement 
          {iterator old = *this; 
          --position; 
          return old; 
          } 

       // equality testing 
       bool operator!=(const typename arrayList<T>::iterator right) const 
         {return position != right.position;} 
       bool operator==(const typename arrayList<T>::iterator right) const 
         {return position == right.position;} 
      protected: 
       T* position; 
      }; // end of iterator class 


    //  class Pointer: public arrayList<T>::iterator { 

    class Pointer:public arrayList<T>::iterator{ 

    public: 
     typedef random_access_iterator_tag iterator_category; 
     typedef T value_type; 
     typedef ptrdiff_t difference_type; 
     typedef T* pointer; 
     typedef T& reference; 
     // constructor 
     Pointer(T *thePosition) { 
      position = thePosition; 
     } 

     Pointer(const Pointer & rhs) 
     { 
      Pointer(rhs.position); 
     } 
     //arithmetic operators 
     Pointer operator+(int n) const; 
     Pointer & operator+=(int n) ; 
     Pointer operator-(int n) const ; 
     Pointer & operator-=(int n) ; 
     reference operator[](difference_type& n)const ; 
     bool operator<(const Pointer &rhs) const ; 
     bool operator<=(const Pointer & rhs) const; 
     bool operator >(const Pointer & rhs) const; 
     bool operator >=(const Pointer &rhs) const ; 
     int operator -(Pointer rhs) ; 

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

     // increment 
     Pointer& operator++() ; 
     Pointer operator++(int) ; 

     // decrement 
     Pointer& operator--() ; 
     Pointer operator--(int) ; 

     // equality testing 
     bool operator!=(const Pointer right) const; 
     bool operator==(const Pointer right) const; 
    protected: 
     T* position; 
    }; 




protected: 
    T* element; // 1D array to hold list elements 
    int arrayLength; // capacity of the 1D array 
    int listSize; // number of elements in list 
}; 



**// main.cpp** 

int main() { 
    ..... 
    sort(dict.begin(),dict.end(),compare_nocase);/////// error 
     .... 
    return 0; 
} 

Les erreurs sont les suivantes:

c:\wascana\mingw\bin\../lib/gcc/mingw32/4.5.0/include/c++/bits/stl_algobase.h:138:7: instantiated from 'void std::iter_swap(_ForwardIterator1, _ForwardIterator2) [with _ForwardIterator1 = arrayList<std::basic_string<char> >::Pointer, _ForwardIterator2 = arrayList<std::basic_string<char> >::Pointer]' 
c:\wascana\mingw\bin\../lib/gcc/mingw32/4.5.0/include/c++/bits/stl_algo.h:111:6: instantiated from 'void std::__move_median_first(_Iterator, _Iterator, _Iterator, _Compare) [with _Iterator = arrayList<std::basic_string<char> >::Pointer, _Compare = bool (*)(std::basic_string<char>, std::basic_string<char>)]' 
c:\wascana\mingw\bin\../lib/gcc/mingw32/4.5.0/include/c++/bits/stl_algo.h:2260:7: instantiated from '_RandomAccessIterator std::__unguarded_partition_pivot(_RandomAccessIterator, _RandomAccessIterator, _Compare) [with _RandomAccessIterator = arrayList<std::basic_string<char> >::Pointer, _Compare = bool (*)(std::basic_string<char>, std::basic_string<char>)]' 
c:\wascana\mingw\bin\../lib/gcc/mingw32/4.5.0/include/c++/bits/stl_algo.h:2302:62: instantiated from 'void std::__introsort_loop(_RandomAccessIterator, _RandomAccessIterator, _Size, _Compare) [with _RandomAccessIterator = arrayList<std::basic_string<char> >::Pointer, _Size = int, _Compare = bool (*)(std::basic_string<char>, std::basic_string<char>)]' 
c:\wascana\mingw\bin\../lib/gcc/mingw32/4.5.0/include/c++/bits/stl_algo.h:5250:4: instantiated from 'void std::sort(_RAIter, _RAIter, _Compare) [with _RAIter = arrayList<std::basic_string<char> >::Pointer, _Compare = bool (*)(std::basic_string<char>, std::basic_string<char>)]' 
..\hw3prob2.cpp:53:45: instantiated from here 
c:\wascana\mingw\bin\../lib/gcc/mingw32/4.5.0/include/c++/bits/stl_algobase.h:101:11: error: no matching function for call to 'swap(std::basic_string<char>, std::basic_string<char>)' 
c:\wascana\mingw\bin\../lib/gcc/mingw32/4.5.0/include/c++/bits/move.h:106:5: note: candidates are: void std::swap(_Tp&, _Tp&) [with _Tp = std::basic_string<char>] 
c:\wascana\mingw\bin\../lib/gcc/mingw32/4.5.0/include/c++/bits/basic_string.h:2564:5: note:     void std::swap(std::basic_string<_CharT, _Traits, _Alloc>&, std::basic_string<_CharT, _Traits, _Alloc>&) [with _CharT = char, _Traits = std::char_traits<char>, _Alloc = std::allocator<char>] 

-je vérifier pendant plusieurs heures, mais ont aucune idée. Merci pour toute aide.

Edit

Enfin, cela fonctionne. Merci beaucoup!!!!!

Answer 1

arrayList<T>::seamlessPointer ne satisfait pas aux exigences d'un itérateur à accès aléatoire. En un coup d'oeil, operator* devrait retourner le type reference, pas T. Et il devrait avoir un constructeur par défaut.

Éditer: Aussi, ce constructeur n'initialise pas l'objet construit.

seamlessPointer(const seamlessPointer & rhs) 
{ 
    seamlessPointer(rhs.position); 
} 

Il construit un seamlessPointer anonyme temporaire et oublie alors à ce sujet. Vous voulez quelque chose comme

seamlessPointer(const seamlessPointer & rhs) 
    : position(rhs.position) 
{ 
} 

Answer 2

Je pense que votre problème est que la fonction operator* a le mauvais type de retour. En ce moment, il est

T operator*() const 

Quand il doit être

T& operator*() const 

, vous revenez actuellement une copie des valeurs que vous nous parcourons plus, alors quand std::sort appelle en interne std::swap pour essayer d'échanger les valeurs , il passera dans des copies des éléments du tableau plutôt que des éléments du tableau eux-mêmes (plus techniquement, rvalues ​​au lieu de lvalues). Changer le type de retour en T& signifie que vous renvoyez la lvalue, qui peut en effet être permutée.

Essayez de changer cela et de voir s'il corrige quoi que ce soit.