¿Cómo inicializar un mapa constante estático privado en C ++?

Solo necesito diccionario o matriz asociativa string=> int.

Hay un mapa de tipos C ++ para este caso.

Pero solo necesito un mapa para todas las instancias (-> estático) y este mapa no se puede cambiar (-> const);

He encontrado esta manera con la biblioteca boost

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

¿Hay otra solución sin esta lib? He intentado algo como esto, pero siempre hay algunos problemas con la inicialización del mapa.

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() {
}

El estándar C ++ 11 introdujo la inicialización uniforme que lo hace mucho más simple si su compilador lo admite:

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

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

Consulte también esta sección de Professional C ++ , en unordered_maps.

¡Lo hice! :)

Funciona bien sin 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);

Si lo encuentra boost::assign::map_list_ofútil, pero no puede usarlo por alguna razón, puede escribir el suyo propio :

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';
}

Es útil saber cómo funcionan estas cosas, especialmente cuando son tan cortas, pero en este caso usaría una función:

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 enfoque diferente 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
}

Esto es más eficiente, ya que no hay una copia de un tipo de pila a pila (incluido el constructor y los destructores de todos los elementos). Si esto importa o no depende de su caso de uso. ¡No importa con cuerdas! (pero puede que encuentre esta versión "más limpia" o no)

Si el mapa va a contener solo entradas que se conocen en el momento de la compilación y las claves del mapa son números enteros, entonces no es necesario utilizar un mapa en absoluto.

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
    }
}

Puedes probar esto:

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 esta implementación, su mapa estático constante de clases es un miembro privado y puede ser accesible para otras clases usando un método get público. De lo contrario, dado que es constante y no puede cambiar, puede eliminar el método public get y mover la variable del mapa a la sección pública de clases. Sin embargo, dejaría el método createMap privado o protegido si se requiere herencia o polimorfismo. A continuación se muestran algunos ejemplos de uso.

 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.

Había editado mi publicación original, no había nada de malo con el código original en el que publiqué para que se compilara, construyera y ejecutara correctamente, era solo que en mi primera versión presenté como respuesta el mapa fue declarado como público y el mapa fue const pero no estático.

Si está utilizando un compilador que aún no admite la inicialización universal o tiene reservas para usar Boost, otra alternativa posible sería la siguiente

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 llamada a función no puede aparecer en una expresión constante.

prueba esto: (solo un ejemplo)

#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
}

A menudo uso este patrón y te recomiendo que lo uses también:

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;

Seguro que no es muy legible, pero sin otras librerías es lo mejor que podemos hacer. Además, no habrá operaciones redundantes como copiar de un mapa a otro como en su intento.

Esto es aún más útil dentro de las funciones: en lugar de:

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

Utilice lo siguiente:

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

No solo ya no es necesario que esté aquí para tratar con la variable booleana, sino que ya no tendrá una variable global oculta que se verifique si el inicializador de la variable estática dentro de la función ya se llamó.