Iterator in C++

Question

Sto provando a creare il mio traduttore. È un lavoro universitario. Ho bisogno di un iteratore nel mio traduttore di classe.

class Translator 
{ 
private: 
    map <string,Word> translator; 

public: 
    class iterator 
    { 
     friend class Translator; 
     private: 
      map<string,Word>::iterator itm; 

     public: 
      iterator operator++(); 
      pair <string,Word> &operator*(); 
      bool operator==(const iterator &it)const; 
    }; 
}; 

sto cercando di sovraccaricare operator*();

Questo è il codice.

pair <string, Word>& Translator::iterator::operator*() 
{ 
    return (*itm); 
} 

errore:

invalid initialization of reference of type ‘std::pair<std::basic_string<char>, Word>&’ from expression of type ‘std::pair<const std::basic_string<char>, Word>

Answer 1

Le chiavi di una mappa sono costanti, in modo che il tipo di valore è pair<const string, Word>.

Alcuni alias tipo potrebbero rendere il codice più amichevole:

typedef map <string,Word> map_type; 
typedef map_type::value_type value_type; 

value_type &operator*(); 

Answer 2

E 'più un complemento che una risposta reale, ma se volete un bel iteratore (STL complient) si dovrà anche aggiungere diversi typedef, per dì ad esempio il tipo del tuo iteratore (nel tuo caso hai un iteratore di input). Quindi puoi usare il tuo iteratore con qualsiasi algoritmo di stl che può essere molto bello. Tuttavia questo può essere piuttosto ingombrante.

Un approccio molto bello sta usando boost facade iterators, è sufficiente riscrivere ciò che è necessario che siano tre metodi per un iteratore di input che specificano come incrementare, verificare se due iteratori sono uguali e dereferenziati. Boost sta quindi facendo tutto il lavoro sporco per te e puoi quindi utilizzare tutti gli algoritmi di stl con i tuoi iteratori conformi standard.

Ecco un esempio dal link che ti ho dato:

# include <boost/iterator/iterator_facade.hpp> 
# include "node.hpp" 
class node_iterator : public boost::iterator_facade< 
    node_iterator 
    , node_base 
    , boost::forward_traversal_tag 
>{ 
public: 
node_iterator() 
    : m_node(0) {} 

explicit node_iterator(node_base* p) 
    : m_node(p) {} 
private: 
friend class boost::iterator_core_access; 

void increment() { m_node = m_node->next(); } 

bool equal(node_iterator const& other) const 
{ 
    return this->m_node == other.m_node; 
} 

node_base& dereference() const { return *m_node; } 

node_base* m_node; 
};