C ++에서 비공개 정적 const 맵을 초기화하는 방법은 무엇입니까?

사전 또는 연관 배열 string=> 만 필요합니다 int.

이 경우 유형 맵 C ++가 있습니다.

하지만 모든 인스턴스 (-> static)에 대해 하나의 맵만 필요하며이 맵은 변경할 수 없습니다 (-> const);

나는 부스트 라이브러리로 이런 방법을 찾았습니다.

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

이 lib가없는 다른 솔루션이 있습니까? 나는 이와 같은 것을 시도했지만 항상 맵 초기화에 몇 가지 문제가 있습니다.

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

C ++ 11 표준은 컴파일러가 지원하는 경우이를 훨씬 더 간단하게 만드는 균일 한 초기화를 도입했습니다.

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

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

무순 맵에 대한 Professional C ++의이 섹션을 참조하십시오 .

내가 해냈어! :)

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);

boost::assign::map_list_of유용하다고 생각하지만 어떤 이유로 사용할 수 없다면 직접 작성할 수 있습니다 .

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

특히 너무 짧을 때 이러한 것들이 어떻게 작동하는지 아는 것이 유용하지만이 경우에는 함수를 사용합니다.

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();

문제에 대한 다른 접근 방식 :

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
}

스택에서 힙 (모든 요소의 생성자, 소멸자 포함)으로의 단일 유형 사본이 없기 때문에 더 효율적입니다. 이것이 중요한지 여부는 사용 사례에 따라 다릅니다. 문자열은 상관 없습니다! (하지만이 버전 "클리너"를 찾을 수도 없을 수도 있습니다.)

맵에 컴파일 시간에 알려진 항목 만 포함되고 맵에 대한 키가 정수인 경우 맵을 전혀 사용할 필요가 없습니다.

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

이것을 시도해 볼 수 있습니다.

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

이 구현을 통해 클래스 상수 정적 맵은 개인 멤버이며 공용 get 메소드를 사용하여 다른 클래스에 액세스 할 수 있습니다. 그렇지 않으면 상수이고 변경할 수 없으므로 public get 메소드를 제거하고 map 변수를 classes public 섹션으로 이동할 수 있습니다. 그러나 상속 및 / 또는 다형성이 필요한 경우 createMap 메서드를 개인 또는 보호 된 상태로 둡니다. 다음은 몇 가지 사용 샘플입니다.

 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.

나는 내 원래 게시물을 편집했고, 내가 올바로 컴파일, 빌드 및 실행하기 위해 게시 한 원래 코드에는 아무런 문제가 없었습니다. 내가 답변으로 제시 한 첫 번째 버전은지도가 공개로 선언되었고지도는 const이지만 정적이 아닙니다.

여전히 범용 초기화를 지원하지 않는 컴파일러를 사용하거나 Boost 사용을 예약 한 경우 가능한 다른 대안은 다음과 같습니다.

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

함수 호출은 상수 표현식에 나타날 수 없습니다.

이것을 시도하십시오 : (단지 예)

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

나는 종종이 패턴을 사용하고 당신도 그것을 사용하는 것이 좋습니다.

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;

물론 읽기가 쉽지는 않지만 다른 라이브러리가 없으면 우리가 할 수있는 최선의 방법입니다. 또한 시도에서와 같이 한 맵에서 다른 맵으로 복사하는 것과 같은 중복 작업이 없습니다.

이것은 함수 내부에서 훨씬 더 유용합니다. 대신 :

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

다음을 사용하십시오.

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

더 이상 부울 변수를 다룰 필요가 없을뿐만 아니라 함수 내부의 정적 변수 이니셜 라이저가 이미 호출되었는지 확인하는 숨겨진 전역 변수가 없습니다.