C ++ const std :: mappa di riferimento non riesce a compilare

Question

C'è un motivo per cui il superamento di un riferimento ad un std::map come const fa sì che l'operatore [] per rompere? Ottengo questo errore del compilatore (gcc 4.2) quando uso const:

  

errore: non è partita per ‘operatore []’ in   ‘Map [nome]’

Ecco il prototipo di funzione:

void func(const char ch, std::string &str, const std::map<std::string, std::string> &map);

E, devo dire che non c'è nessun problema quando rimuovo la parola chiave const davanti std::map.

Se sono stato incaricato in modo corretto, l'operatore [] sarà effettivamente inserire una nuova coppia nella mappa se non trova la chiave, che naturalmente spiegare perché questo accade, ma non riesco a immaginare che questo avrebbe mai essere un comportamento accettabile.

Se c'è un metodo migliore, come l'utilizzo di find al posto di [], lo apprezzerei. Io non riesco a ottenere trovare per lavorare sia anche se ... riceverò const di errori non corrispondenti iteratore.

Answer 1

Sì, non è possibile utilizzare operator[]. Utilizzare find, ma è da notare restituisce const_iterator invece di iterator:

std::map<std::string, std::string>::const_iterator it;
it = map.find(name);
if(it != map.end()) {
    std::string const& data = it->second;
    // ...
}

E 'come con i puntatori. Non è possibile assegnare a int const* int*. Allo stesso modo, non è possibile assegnare a const_iterator iterator.

Answer 2

Quando si utilizza operatore [], std :: map guarda per elemento con data chiave. Se non trova alcuna, lo crea. Quindi il problema con const.

Usa trovare il metodo e non avrete problemi.

Potete per favore inserire il codice su come si sta cercando di usare find ()? Il modo giusto potrebbe essere:

if( map.find(name) != map.end() )
{
   //...
}

Answer 3

Se stai usando C ++ 11, std :: :: mappa a dovrebbe funzionare per voi.

Il motivo std :: mappa :: operator [] non funziona è che nel caso della chiave che stai cercando non esistente nella mappa, si inserisce un nuovo elemento utilizzando la chiave in dotazione e restituisce un riferimento ad esso (Vedi il link per i dettagli). Questo non è possibile su una std :: map const.

Il 'al' metodo, tuttavia, sarà un'eccezione se la chiave non esiste. Detto questo, è probabilmente una buona idea per verificare l'esistenza della chiave utilizzando la std :: mappa :: trovare il metodo prima di tentare di accedere all'elemento con il metodo 'a'.

Answer 4

Probabilmente perché non c'è nessun operatore const [] in std :: map. operatore [] aggiungerà l'elemento che stai cercando, se non lo trova. Pertanto, utilizzare il metodo find () se si desidera cercare, senza la possibilità di aggiungere.

Answer 5

Per i tuoi "errori non corrispondenti iteratori const":

find () ha due overload:

      iterator find ( const key_type& x );
const_iterator find ( const key_type& x ) const;

Il mio indovinare è che stai ricevendo questo errore perché si sta facendo qualcosa di simile l'assegnazione di un iteratore non const (a sinistra) al risultato di una chiamata find() su una mappa const:

iterator<...> myIter /* non-const */ = myConstMap.find(...)

Ciò si tradurrebbe in un errore, anche se forse non quello che si sta vedendo.