Come creare una std :: mappa di valori costanti che è ancora accessibile dall'operatore []?

Question

Ho bisogno di una std: struttura dati della mappa che è di sola lettura, il che significa che devo riempirla una volta con i dati e quindi leggere solo quei valori, non cambiarli mai o aggiungerne di nuovi.

La mia versione non-const assomiglia a questo:

//in .h 
#include <string> 
#include <map> 

std::map<std::string, int> myMap; 
void initMap(); 

//in .cpp 
#include "foo.h" 

void initMap() { 
    myMap["Keys"] = 42; 
} 

Poi io chiamerei initMap() una volta nel mio codice e sia fatta.

Ora ho già letto diverse domande qui e sembra non banale raggiungere la costanza per la mappa.

Facendolo diventare un std::map<std::string, const int> non mi consente di riempirlo nello initMap(). Il riempimento con un temp non costante e il costruttore di copie sulla definizione non funziona, in quanto il costruttore di copie non accetta facilmente la versione non const come input.

Facendolo diventare un const std::map<std::string, int> (che potrei riempire con una copia non costante durante la definizione) disabiliterebbe l'uso dell'operatore [] per l'accesso ai valori.

Quindi c'è un modo per raggiungere (valore) constinità e inizializzare la struttura (preferibilmente nel file di intestazione)?

BTW: Né C++ 0x né C++ 11 né boost:: è un'opzione.

Answer 1

Non potresti utilizzare il metodo insert() disponibile per std::map?

http://www.cplusplus.com/reference/map/map/insert/

Edit: (soluzione) myMap.insert(std::pair<std::string, const int>("Keys", 42));

Per quanto mi risulta, la ragione per cui questo funziona è perché il costruttore per la coppia, pair (const first_type& a, const second_type& b), inizializza i suoi membri first e second utilizzando i costruttori per first_type e second_type, prendendo a e come rispettivo parametro.

Con la soluzione che stavi cercando di utilizzare, la mia comprensione è che myMap["Keys"] = 42; inizializza il membro second della map (di tipo const int) utilizzando il costruttore predefinito per int. Quindi si tenta di assegnare un valore a quel membro. Poiché questo viene eseguito al di fuori del costruttore della classe map, la dichiarazione const rende impossibile ciò.

Con la soluzione che utilizza insert(), i membri vengono inizializzati nel costruttore di pair. Quindi possono essere dichiarati const. La stessa operazione viene eseguita quando lo pair viene copiato su map.

Answer 2

Anche se questo non è possibile per voi, gli altri che vuole fare questo e che hanno un compilatore compatibile con C++ 11, potrebbe usare uniform initialization:

std::map<std::string, const int> myMap = { 
    { "keys", 42 } 
}; 

---

Oh, e dal modo in cui, don 't definire la mappa nel file di intestazione. Invece dichiarare come extern nel file di intestazione, quindi definirlo nel file di origine.

Answer 3

Se il map non può essere modificato, è necessario utilizzare const map<string, int> e non map<string, const int>: la seconda versione consente l'inserimento e la cancellazione di oggetti.

Purtroppo, si dovrà perdere l'operatore []; C++ non ha uno ImmutableMap, o qualcosa del genere. Tuttavia, std::map::at e std::map::find non sono male ...

Answer 4

La soluzione più semplice è quella di scrivere il proprio, avvolgendo il classe di mappa standard:

template <typename KeyType, typename MappedType, typename CmpType> 
class ConstantMap 
{ 
    typedef std::map<KeyType, MappedType, CmpType> Impl; 
    Impl myImpl; 
public: 
    typedef Impl::value_type value_type; 

    template <ForwardIterator> 
    ConstantMap(ForwardIterator begin, ForwardIterator end, CmpType cmp = CmpType()) 
     : myImpl(begin, end, cmp) 
    { 
    } 

    // necessary if [] is not going to work for missing keys 
    bool contains(KeyType const& key) const 
    { 
     return myImpl.find(key) != myImpl.end(); 
    } 

    MappedType const& operator[](KeyType const& key) const 
    { 
     Impl::const_iterator elem = myImpl.find(key); 
     if (elem == myImpl.end()) { 
      // Not found, do what you want (maybe throw an exception) 
     } 
     return elem.second; 
    } 
}; 

È possibile initialze la mappa passandolo iteratori a una sequenza di tutto ciò che può convertire a value_type.

A seconda delle esigenze, si consiglia di aggiungere ulteriori typedef inoltro, funzioni, ecc Se stai usando C++ 11, si consiglia inoltre di creare un costruttore che può utilizzare un elenco di inizializzazione.

Answer 5

Qualcosa di molto semplice, che ha un ingombro più piccolo ed è più veloce:

static const int MyMapData[] = { 
    42  // index 0 is mapped to "key" 
};
 

struct MyMap 
{ 
    const int& operator[](std::string key) const 
    { 
     switch (key) { 
      case "Keys": return MyMapData[0];
 

 default: return NotANumber;  // Return 0 and raise an assertion, or return "Not a Number". 
    } 
} 

};

Facile da mantenere, nessun uso di modelli, nessun utilizzo di librerie boost e compilabili ovunque.