496

初始化静态地图的正确方法是什么？我们需要一个静态函数来初始化它吗？

4

12 回答 12

691

使用 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');
于 2008-09-26T10:17:44.530 回答
141

Best way is to use a function:

#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();
于 2008-09-26T10:22:55.983 回答
116

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

注意：以前我使用 aoperator []添加实际值。正如 dalle 所评论的那样，这是不可能的。

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

于 2009-11-13T17:37:17.997 回答
46

这是使用 2 元素数据构造函数的另一种方法。不需要任何函数来初始化它。没有第 3 方代码（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} };
于 2010-01-19T20:06:02.573 回答
30

例如：

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
        };
};
于 2016-12-28T19:51:27.137 回答
25

我会将地图包装在一个静态对象中，并将地图初始化代码放入该对象的构造函数中，这样您就可以确保在执行初始化代码之前创建地图。

于 2008-09-26T10:19:19.033 回答
19

只是想分享一个纯 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;
于 2014-07-10T17:56:56.493 回答
16

你可以试试：

std::map <int, int> mymap = 
{
        std::pair <int, int> (1, 1),
        std::pair <int, int> (2, 2),
        std::pair <int, int> (2, 2)
};
于 2016-09-10T07:33:33.630 回答
9

这类似于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);
于 2009-11-13T19:06:02.157 回答
9

如果你被 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 ] ) ] );
于 2017-03-07T13:47:34.260 回答
1

除了使用的最佳答案之外

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++。）

于 2021-03-15T09:05:10.563 回答
-6

你在这里有一些很好的答案，但我对我来说，这看起来像是“当你所知道的只是一把锤子”......

为什么没有标准方法来初始化静态地图的最简单答案是没有充分的理由使用静态地图......

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

优点很多... - 更快的性能（*4，我在许多 CPU 类型上测量过，它总是在 4 左右） - 更简单的调试。更容易看到线性布局发生了什么。- 如果有必要，复制操作的简单实现。- 它在运行时不分配内存，因此永远不会抛出异常。- 这是一个标准接口，因此很容易在 DLL 或语言等之间共享。

我可以继续说下去，但如果你想要更多，为什么不看看 Stroustrup 关于这个主题的许多博客。

于 2014-07-05T09:31:04.490 回答