Answers:
使用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();
const map<int,int> m = create_map()
(因此,可在初始化列表中初始化类的const成员:struct MyClass {const map<int, int> m; MyClass(); }; MyClass::MyClass() : 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; //稍后在代码中的某个位置 map_add_values <int,int>(my_map)(1,2)(3,4)(5,6);
注意:以前我使用operator []
来添加实际值。正如dalle所说,这是不可能的。
#####################过时部分的结尾######################
operator[]
只需要一个参数。
error: conflicting declaration ‘map_add_values<int, int> my_map’
error: ‘my_map’ has a previous declaration as ‘std::map<int, int> my_map’
这是使用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} };
例如:
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是类的数据成员,则可以通过以下方式直接在标头中对其进行初始化(从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解决方法:
#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)
};
{1, 2}
代替std::pair<int, int>(1, 2)
。
如果您坚持使用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 ] ) ] );
您在这里有一些很好的答案,但是我对我来说,就像是“当您只知道一把锤子时”的情况。
为什么没有初始化静态地图的标准方法的最简单答案是,没有充分的理由使用静态地图...
地图是为快速查找而设计的结构,其中包含一组未知的元素。如果您事先了解元素,则只需使用C数组即可。如果无法执行此操作,请以排序方式输入值,或对其进行排序。然后,您可以使用stl :: functions来循环记录lower_bound / upper_bound项,从而获得log(n)性能。当我之前对此进行测试时,它们通常比地图快至少4倍。
优点是多方面的...-更快的性能(* 4,我已经在许多CPU类型上进行过测量,总是在4左右)-调试更简单。看到线性布局发生了什么就更容易了。-复制操作的简单实现,如果有必要的话。-它在运行时不分配内存,因此永远不会引发异常。-这是标准接口,因此很容易在DLL或语言等之间共享。
我可以继续,但是如果您想要更多,为什么不看看Stroustrup关于该主题的许多博客。
map
也是表示部分函数(数学意义上的函数;但从编程意义上来说也是一种)的有用形式。数组不这样做。例如,您不能使用字符串从数组中查找数据。