如何在C ++中初始化私有静态常量映射？
我只需要字典或关联数组string => int 。
这种情况下有types映射C ++。
但是我只需要一个map实例（ – > static），这个map不能改变（ – > const）;
我用boost库find了这个方法
std::map<int, char> example = boost::assign::map_list_of(1, 'a') (2, 'b') (3, 'c');
有没有这个lib的其他解决scheme？ 我已经尝试了这样的事情，但总是有一些地图初始化的问题。
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} };
另请参阅专业C ++中的unordered_maps部分。
如果你发现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();
我做的！ 🙂
没有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);
如果地图只包含在编译时已知的条目，并且地图的键是整数，则根本不需要使用地图。
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 } }
解决问题的另一种方法是：
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 }
这样更有效率，因为没有从堆栈到堆的单一types副本（包括构造函数，所有元素上的析构函数）。 这是否重要取决于您的使用情况。 与弦无关！ （但你可能会或可能不会觉得这个版本“更清洁”）
如果您使用的编译器仍然不支持通用初始化，或者您在使用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; }();
你可以试试这个：
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方法，并将mapvariables移动到public类的公共部分。 不过，如果需要inheritance和/或多态性，我会将createMap方法保留为private或protected。 这里有一些使用的样本。
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.
我编辑了我原来的post，原来的代码没有错，我发布了它编译，构build和正确运行，这只是我提出的第一个版本作为答案地图被宣布为公共和地图是const，但不是静态的。
函数调用不能出现在常量expression式中。
试试这个:(只是一个例子）
#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 }
我经常使用这种模式，并build议您使用它：
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;
当然这不是很可读，但没有其他的库，最好我们可以做。 此外，不会有任何多余的操作，如从您的尝试像从一张地图复制到另一个。
这在function内更有用：代替：
void foo() { static bool initComplete = false; static Map map; if (!initComplete) { initComplete = true; map= ...; } }
使用以下内容：
void bar() { struct MyMap : Map { MyMap() { ... } } static mymap; }
不仅你不需要在这里处理布尔variables，你将不会有隐藏的全局variables，如果已经调用函数内部的静态variables的初始化方法，那么将检查它。
