初始化一个静态std::map<int, int>在c++中

初始化静态映射的正确方法是什么?我们是否需要一个静态函数来初始化它?

561063 次浏览
小开

使用c++ 11:

#include <map>
using namespace std;


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

使用提振。分配:

#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();
小开

制作类似boost的东西并不复杂。这里是一个只有三个函数(包括构造函数)的类，用于复制boost所做的工作(几乎)。

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

上面的代码最适合初始化全局变量或类的静态成员，这些类需要初始化，而且你不知道它什么时候第一次被使用，但你想确保其中的值可用。

比如，你必须在现有的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+时将失败。请参阅上面的代码，了解如何将添加值转换为现有映射。


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所评论的那样，这是不可能的。

##################### 过时的结束部分 #####################

小开

这类似于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);
小开

下面是使用2元素数据构造函数的另一种方式。不需要函数来初始化它。没有第三方代码(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} };
小开

你有一些非常好的答案，但对我来说，这看起来就像“当你所知道的只是一把锤子”……

为什么没有标准的方法来初始化静态映射，最简单的答案是没有好的理由去使用静态映射……

映射是为快速查找未知元素集而设计的结构。如果您事先知道元素，只需使用c数组即可。以排序的方式输入值，如果不能这样做，也可以对它们运行排序。然后，您可以通过使用stl::函数循环输入lower_bound/upper_bound来获得log(n)性能。当我之前测试这个时，它们通常比地图快至少4倍。

好处很多… -更快的性能(*4，我测量过许多类型的CPU，它总是在4左右) -调试更简单。线性布局更容易看到发生了什么。 -复制操作的琐碎实现，如果这成为必要的。 -它在运行时不分配内存，因此永远不会抛出异常。 -它是一个标准的接口，因此非常容易跨DLL或语言共享

我可以继续列举，但如果你想了解更多，为什么不看看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;
小开

你可以试试:

std::map <int, int> mymap =
{
std::pair <int, int> (1, 1),
std::pair <int, int> (2, 2),
std::pair <int, int> (2, 2)
};
小开

例如:

const std::map<LogLevel, const char*> g_log_levels_dsc =
{
{ LogLevel::Disabled, "[---]" },
{ LogLevel::Info,     "[inf]" },
{ LogLevel::Warning,  "[wrn]" },
{ LogLevel::Error,    "[err]" },
{ LogLevel::Debug,    "[dbg]" }
};

如果map是一个类的数据成员，你可以通过以下方式直接在header中初始化它(自c++ 17开始):

// Example


template<>
class StringConverter<CacheMode> final
{
public:
static auto convert(CacheMode mode) -> const std::string&
{
// validate...
return s_modes.at(mode);
}


private:
static inline const std::map<CacheMode, std::string> s_modes =
{
{ CacheMode::All, "All" },
{ CacheMode::Selective, "Selective" },
{ CacheMode::None, "None" }
// etc
};
};
小开

如果你被c++ 98所困，不想使用boost，这里有一个解决方案，当我需要初始化一个静态映射时，我使用:

typedef std::pair< int, char > elemPair_t;
elemPair_t elemPairs[] =
{
elemPair_t( 1, 'a'),
elemPair_t( 3, 'b' ),
elemPair_t( 5, 'c' ),
elemPair_t( 7, 'd' )
};


const std::map< int, char > myMap( &elemPairs[ 0 ], &elemPairs[ sizeof( elemPairs ) / sizeof( elemPairs[ 0 ] ) ] );
小开

除了使用的好答案

const std::map<int, int> m = \{\{1,1},{4,2},{9,3},{16,4},{32,9}}

还有一种可能是直接调用lambda，这在一些情况下是有用的:

const std::map<int, int> m = []()->auto {
std::map<int, int> m;
m[1]=1;
m[4]=2;
m[9]=3;
m[16]=4;
m[32]=9;
return m;
}();

显然，一个简单的初始化列表在从头开始用文字值编写时更好，但它确实开辟了其他可能性:

const std::map<int, int> m = []()->auto {
std::map<int, int> m;
for(int i=1;i<5;++i) m[i*i]=i;
m[32]=9;
return m;
}();

(显然，如果你想重用它，它应该是一个正常的函数;这确实需要最新的c++。)


提交答案