c++ - 在C++,初始化静态std::map<int, int>

什么是初始化静态映射的正确方法?

时间:

使用C++ 11 :


#include <map>
using namespace std;

map<int, char> m = {{1, 'a'}, {3, 'b'}, {5, 'c'}, {7, 'd'}};

使用Boost.Assign


#include <map>
#include"boost/assign.hpp"
using namespace std;
using namespace boost::assign;

map<int, char> m = map_list_of (1, 'a') (3, 'b') (5, 'c') (7, 'd');

最好的方法是使用函数:


#include <map>

using namespace std;

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

map<int,int> m = create_map();

下面是一个包含三个函数的类,包括构造函数。


template <typename T, typename U>
class create_map
{
private:
 std::map<T, U> m_map;
public:
 create_map(const T& key, const U& val)
 {
 m_map[key] = val;
 }

 create_map<T, U>& operator()(const T& key, const U& val)
 {
 m_map[key] = val;
 return *this;
 }

 operator std::map<T, U>()
 {
 return m_map;
 }
};

使用方法:

std::map mymap = create_map<int, int >(1,2)(3,4)(5,6);

上面的代码最适合初始化需要初始化的类的全局变量或static成员。

例如,你必须将元素插入到现有的std::map中,


template <typename MapType>
class map_add_values {
private:
 MapType mMap;
public:
 typedef typename MapType::key_type KeyType;
 typedef typename MapType::mapped_type MappedType;

 map_add_values(const KeyType& key, const MappedType& val)
 {
 mMap[key] = val;
 }

 map_add_values& operator()(const KeyType& key, const MappedType& val) {
 mMap[key] = val;
 return *this;
 }

 void to (MapType& map) {
 map.insert(mMap.begin(), mMap.end());
 }
};

使用方法:


typedef std::map<int, int> Int2IntMap;
Int2IntMap testMap;
map_add_values<Int2IntMap>(1,2)(3,4)(5,6).to(testMap);

GCC 4.7.2: http://ideone.com/3uYJiH

###############下面的所有内容都是过时的#################

下面的map_add_values类是,那么我建议的原始解决方案,当它到达GCC 4.5 时会失败,请查看上面的代码,了解如何向现有map中添加值。



template<typename T, typename U>
class map_add_values
{
private:
 std::map<T,U>& m_map;
public:
 map_add_values(std::map<T, U>& _map):m_map(_map){}
 map_add_values& operator()(const T& _key, const U& _val)
 {
 m_map[key] = val;
 return *this;
 }
};

使用方法:

std::map<int, int> my_map;
// Later somewhere along the code
map_add_values<int,int>(my_map)(1,2)(3,4)(5,6);

注:以前我使用operator []来添加实际值,就像dalle所说,这是不可能的。

#####################已过时的结尾 #####################

不需要函数来初始化它,没有第三方代码(Boost ),没有静态函数或对象,没有技巧,仅是简单的C++ :


#include <map>
#include <string>

typedef std::map<std::string, int> MyMap;

const MyMap::value_type rawData[] = {
 MyMap::value_type("hello", 42),
 MyMap::value_type("world", 88),
};
const int numElems = sizeof rawData / sizeof rawData[0];
MyMap myMap(rawData, rawData + numElems);

C 11过时了,你现在可以使用新的初始值设定项列表功能直接初始化STL容器:


const MyMap myMap = { {"hello", 42}, {"world", 88} };

我会包装里面的地图一个静态的对象,并将地图这个对象的构造函数中初始化代码,创建地图这样你肯定之前执行的初始化代码。

这与PierreBdR类似,不复制映射。


#include <map>

using namespace std;

bool create_map(map<int,int> &m)
{
 m[1] = 2;
 m[3] = 4;
 m[5] = 6;
 return true;
}

static map<int,int> m;
static bool _dummy = create_map (m);

你在这里有一些很好的答案,但我对我来说,看起来像"当你只知道锤子"的一个例子。

对于为什么没有标准的方法来初始化静态映射,最简单的答案是没有足够的理由使用静态映射。

映射是为快速查找而设计的一种结构,它是一组未知的元素。 如果你知道前面的元素,只需使用 C-array 。 以排序方式输入值,如果不能,请对它们进行排序。 你可以得到 log(n) 性能通过使用 stl::functions loop-up条目, lower_bound/upper_bound 。 当我测试过这之前,他们通常至少执行 4倍的速度。

优点是许多折叠。。 - 更快的性能( *4,我已经测量了很多类型的cpu,它总是在 4 ) - 更简单的调试。 更容易看到线性布局所发生的事情。 - 复制操作的琐碎实现,如果需要的话。 - 它在运行时不分配内存,所以不会抛出异常。 - 这是一个标准接口,所以很容易跨动态链接库或者语言共享。

我可以继续,但如果你想要更多,为什么不在主题上查看很多stroustrup博客。

只想共享一个纯C++ 98解决方法:


#include <map>

std::map<std::string, std::string> aka;

struct akaInit
{
 akaInit()
 {
 aka["George" ] ="John";
 aka["Joe" ] ="Al";
 aka["Phil" ] ="Sue";
 aka["Smitty" ] ="Yando";
 }
} AkaInit;

...