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


当前回答

使用c++ 11:

#include <map>
using namespace std;

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

使用Boost。分配:

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

其他回答

如果你被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 ] ) ] );

这类似于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} };

制作类似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);

注意:前面我使用运算符[]来添加实际值。正如dalle所评论的那样,这是不可能的。

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

只是想分享一个纯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;