Come inizializzare una mappa const statica privata in C ++?

Ho bisogno solo di un dizionario o di un array associativo string=> int.

C'è la mappa dei tipi C ++ per questo caso.

Ma ho bisogno di una sola mappa per tutte le istanze (-> statica) e questa mappa non può essere modificata (-> const);

Ho trovato questo modo con la libreria boost

 std::map<int, char> example = 
      boost::assign::map_list_of(1, 'a') (2, 'b') (3, 'c');

C'è un'altra soluzione senza questa libreria? Ho provato qualcosa di simile, ma ci sono sempre alcuni problemi con l'inizializzazione della mappa.

class myClass{
private:
    static map<int,int> create_map()
        {
          map<int,int> m;
          m[1] = 2;
          m[3] = 4;
          m[5] = 6;
          return m;
        }
    static map<int,int> myMap =  create_map();

};

#include <map>
using namespace std;

struct A{
    static map<int,int> create_map()
        {
          map<int,int> m;
          m[1] = 2;
          m[3] = 4;
          m[5] = 6;
          return m;
        }
    static const map<int,int> myMap;

};

const map<int,int> A:: myMap =  A::create_map();

int main() {
}

Lo standard C ++ 11 ha introdotto l'inizializzazione uniforme che lo rende molto più semplice se il tuo compilatore lo supporta:

//myClass.hpp
class myClass {
  private:
    static map<int,int> myMap;
};

//myClass.cpp
map<int,int> myClass::myMap = {
   {1, 2},
   {3, 4},
   {5, 6}
};

Vedi anche questa sezione da Professional C ++ , su unordered_maps.

L'ho fatto! :)

Funziona bene senza C ++ 11

class MyClass {
    typedef std::map<std::string, int> MyMap;

    struct T {
        const char* Name;
        int Num;

        operator MyMap::value_type() const {
            return std::pair<std::string, int>(Name, Num);
        }
    };

    static const T MapPairs[];
    static const MyMap TheMap;
};

const MyClass::T MyClass::MapPairs[] = {
    { "Jan", 1 }, { "Feb", 2 }, { "Mar", 3 }
};

const MyClass::MyMap MyClass::TheMap(MapPairs, MapPairs + 3);

Se trovi boost::assign::map_list_ofutile, ma non puoi usarlo per qualche motivo, potresti scrivere il tuo :

template<class K, class V>
struct map_list_of_type {
  typedef std::map<K, V> Map;
  Map data;
  map_list_of_type(K k, V v) { data[k] = v; }
  map_list_of_type& operator()(K k, V v) { data[k] = v; return *this; }
  operator Map const&() const { return data; }
};
template<class K, class V>
map_list_of_type<K, V> my_map_list_of(K k, V v) {
  return map_list_of_type<K, V>(k, v);
}

int main() {
  std::map<int, char> example = 
    my_map_list_of(1, 'a') (2, 'b') (3, 'c');
  cout << example << '\n';
}

È utile sapere come funzionano queste cose, specialmente quando sono così brevi, ma in questo caso userei una funzione:

a.hpp

struct A {
  static map<int, int> const m;
};

a.cpp

namespace {
map<int,int> create_map() {
  map<int, int> m;
  m[1] = 2; // etc.
  return m;
}
}

map<int, int> const A::m = create_map();

Un approccio diverso al problema:

struct A {
    static const map<int, string> * singleton_map() {
        static map<int, string>* m = NULL;
        if (!m) {
            m = new map<int, string>;
            m[42] = "42"
            // ... other initializations
        }
        return m;
    }

    // rest of the class
}

Questo è più efficiente, poiché non esiste una copia di un tipo dallo stack all'heap (inclusi il costruttore, i distruttori su tutti gli elementi). Se questo è importante o meno dipende dal tuo caso d'uso. Non importa con le stringhe! (ma potresti o meno trovare questa versione "più pulita")

Se la mappa deve contenere solo voci note al momento della compilazione e le chiavi della mappa sono numeri interi, non è necessario utilizzare una mappa.

char get_value(int key)
{
    switch (key)
    {
        case 1:
            return 'a';
        case 2:
            return 'b';
        case 3:
            return 'c';
        default:
            // Do whatever is appropriate when the key is not valid
    }
}

Potresti provare questo:

MyClass.h

class MyClass {
private:
    static const std::map<key, value> m_myMap; 
    static const std::map<key, value> createMyStaticConstantMap();
public:
    static std::map<key, value> getMyConstantStaticMap( return m_myMap );
}; //MyClass

MyClass.cpp

#include "MyClass.h"

const std::map<key, value> MyClass::m_myMap = MyClass::createMyStaticConstantMap();

const std::map<key, value> MyClass::createMyStaticConstantMap() {
    std::map<key, value> mMap;
    mMap.insert( std::make_pair( key1, value1 ) );
    mMap.insert( std::make_pair( key2, value2 ) );
    // ....
    mMap.insert( std::make_pair( lastKey, lastValue ) ); 
    return mMap;
} // createMyStaticConstantMap

Con questa implementazione, la mappa statica costante delle classi è un membro privato e può essere accessibile ad altre classi utilizzando un metodo get pubblico. Altrimenti poiché è costante e non può cambiare, è possibile rimuovere il metodo get public e spostare la variabile map nella sezione public delle classi. Tuttavia lascerei il metodo createMap privato o protetto se è richiesta l'ereditarietà e / o il polimorfismo. Ecco alcuni esempi di utilizzo.

 std::map<key,value> m1 = MyClass::getMyMap();
 // then do work on m1 or
 unsigned index = some predetermined value
 MyClass::getMyMap().at( index ); // As long as index is valid this will 
 // retun map.second or map->second value so if in this case key is an
 // unsigned and value is a std::string then you could do
 std::cout << std::string( MyClass::getMyMap().at( some index that exists in map ) ); 
// and it will print out to the console the string locted in the map at this index. 
//You can do this before any class object is instantiated or declared. 

 //If you are using a pointer to your class such as:
 std::shared_ptr<MyClass> || std::unique_ptr<MyClass>
 // Then it would look like this:
 pMyClass->getMyMap().at( index ); // And Will do the same as above
 // Even if you have not yet called the std pointer's reset method on
 // this class object. 

 // This will only work on static methods only, and all data in static methods must be available first.

Avevo modificato il mio post originale, non c'era niente di sbagliato nel codice originale in cui l'ho pubblicato compilato, costruito ed eseguito correttamente, era solo che la mia prima versione che ho presentato come risposta la mappa è stata dichiarata pubblica e la mappa è stata const ma non era statico.

Se stai usando un compilatore che ancora non supporta l'inizializzazione universale o hai una prenotazione nell'usare Boost, un'altra possibile alternativa sarebbe la seguente

std::map<int, int> m = [] () {
    std::pair<int,int> _m[] = {
        std::make_pair(1 , sizeof(2)),
        std::make_pair(3 , sizeof(4)),
        std::make_pair(5 , sizeof(6))};
    std::map<int, int> m;
    for (auto data: _m)
    {
        m[data.first] = data.second;
    }
    return m;
}();

Una chiamata di funzione non può apparire in un'espressione costante.

prova questo: (solo un esempio)

#include <map>
#include <iostream>

using std::map;
using std::cout;

class myClass{
 public:
 static map<int,int> create_map()
    {
      map<int,int> m;
      m[1] = 2;
      m[3] = 4;
      m[5] = 6;
      return m;
    }
 const static map<int,int> myMap;

};
const map<int,int>myClass::myMap =  create_map();

int main(){

   map<int,int> t=myClass::create_map();
   std::cout<<t[1]; //prints 2
}

Uso spesso questo schema e ti consiglio di usarlo anche:

class MyMap : public std::map<int, int>
{
public:
    MyMap()
    {
        //either
        insert(make_pair(1, 2));
        insert(make_pair(3, 4));
        insert(make_pair(5, 6));
        //or
        (*this)[1] = 2;
        (*this)[3] = 4;
        (*this)[5] = 6;
    }
} const static my_map;

Certo non è molto leggibile, ma senza altre librerie è meglio che possiamo fare. Inoltre non ci saranno operazioni ridondanti come la copia da una mappa all'altra come nel tuo tentativo.

Questo è ancora più utile all'interno delle funzioni: invece di:

void foo()
{
   static bool initComplete = false;
   static Map map;
   if (!initComplete)
   {
      initComplete = true;
      map= ...;
   }
}

Utilizza il seguente:

void bar()
{
    struct MyMap : Map
    {
      MyMap()
      {
         ...
      }
    } static mymap;
}

Non solo non è più necessario che tu abbia a che fare con la variabile booleana, non avrai più la variabile globale nascosta che viene controllata se l'inizializzatore della variabile statica all'interno della funzione è già stato chiamato.