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

Question

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

c++stlstdmap

536

如何正确初始化静态映射？我们需要一个静态函数来初始化它吗？

- Nithin

12个回答

139

最好的方法是使用函数：

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

- PierreBdR

26

为什么这是“最好的”？例如，为什么它比@Dreamer的答案更好？ - user207421

7

我认为它是“最好的”，因为它非常简单，并且不依赖于其他已经存在的结构（例如Boost :: Assign或其重新实现）。与@Dreamer的答案相比，我避免创建一个完整的结构来初始化一个映射... - PierreBdR

3

注意这里存在一个危险。如果编译器只看到了 extern 声明但尚未遇到实际的变量定义，那么在“main”函数运行之前的构造期间，extern 变量将不会具有其正确的值。请注意，此处指的是变量的实际定义，而非仅仅是声明。 - bobobobo

5

危险在于没有规定静态变量应该按照哪个顺序进行初始化（至少在编译单元之间），但这不是与本问题相关的问题。这是静态变量普遍存在的问题。 - PierreBdR

8

无 boost 和无 C++11 => +1。请注意，函数可用于初始化const map<int,int> m = create_map()（从而可以在类的初始化列表中初始化常量成员：struct MyClass {const map<int, int> m; MyClass(); }; MyClass::MyClass() : m(create_map())）。 - ribamar

显示剩余5条评论

117

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

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

- Vite Falcon

3

我将您的第一个示例用作<int，string>，将错误编号（来自枚举）和消息绑定在一起 - 它的效果非常好 - 谢谢。 - slashmais

1

operator[] 只接受一个参数。 - dalle

1

@dalle：干得好！出于某种原因，我以为重载的 [] 运算符可以接受更多东西。 - Vite Falcon

3

这是一个非常棒的答案。很遗憾，原帖作者从未选择其中一个。你应该得到巨大的赞誉。 - Thomas Thorogood

map_add_values在gcc中无法工作，gcc会报错： error: conflicting declaration ‘map_add_values<int, int> my_map’ error: ‘my_map’ has a previous declaration as ‘std::map<int, int> my_map’ - Martin Wang

显示剩余12条评论

46

这里有另一种方法，它使用了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} };

- Brian Neal

37

例如：

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

- isnullxbh

在这个例子中，最好使用 std::array。 - prehistoricpenguin

@prehistoricpenguin，为什么？ - isnullxbh

出于性能考虑，这个函数可能是一个热点，使用std::array比使用map查找更快。 - prehistoricpenguin

@prehistoricpenguin，你能提供一个使用std::array的例子吗？ - isnullxbh

请您看一下：https://quick-bench.com/q/NdDNwTxQaSqEdSoLtehY_dc_ZNQ - prehistoricpenguin

2

也许对于CPU性能来说…但是如果不知道LogLevel的整数值，那么你在内存性能方面就存在风险。在数组中使用这个枚举类型会非常糟糕。枚举类型LogLevel { Disabled=-100, Info, Warning=500, Error, Debug=32768 }; - unpoetical

26

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

- Drealmer

1

我完全同意你的观点。这也稍微快一些 :) - QBziZ

3

比什么快？比带有初始化器的全局静态变量还要快吗？不，它不是（记住返回值优化）。 - Pavel Minaev

9

好的回答。如果我能看到实际的代码示例，我会很高兴。 - Sungguk Lim

20

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

- user3826594

2

这对于没有默认构造函数的对象不起作用，我认为应该首选插入方法。 - Alessandro Teruzzi

14

您可以尝试：

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

- Dmitry Oberemchenko

3

在C++11之前，您不能将初始化列表与非聚合类型一起使用，此时您可以使用更短的语法{1, 2}代替std::pair<int, int>(1, 2)。 - Ferruccio

10

如果您被困在使用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 ] ) ] );

- Emanuele Benedetti

8

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

- eduffy

12

无论如何，它可能都不会被复制。 - GManNickG

2

但这种方式，映射表就不能是静态常量了，是吗？ - xmoex

网页内容由stack overflow 提供, 点击上面的

可以查看英文原文，
原文链接

- Ferruccio · Accepted Answer

739

使用C++11初始化列表{{},{},...}。初始化元素的顺序并不重要。地图将通过键为您进行排序。如果初始化unordered_map，则是相同的原理，其中排序顺序将由哈希函数确定，并且在人眼中看起来是随机的：

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

- Ferruccio

136

每次我看到用C++做这样的事情时，就会想到必须有许多可怕的模板代码在背后支撑。好的例子！ - Greg Hewgill

38

实现这些实用程序的可怕模板代码的优美之处在于它被整齐地封装在一个库中，最终用户很少需要处理复杂性。 - Steve Guidi

47

如果你的公司拒绝使用Boost库，理由是它不够“标准”，那么我想知道什么样的C++库才能被认为足够“标准”。对于C++程序员来说，Boost库是必备的标准工具。请注意，我的翻译保留了原文的意思和语气，并且尽可能通俗易懂。 - DevSolar

53

我对Boost（在这里以及其他地方）的问题在于，通常情况下你可以不使用它（在这种情况下可以使用C++11或之前的版本通过一个函数）。Boost增加了很多编译时间开销，并且需要将大量文件保存到代码库中（如果你要创建一个存档文件，则还需要复制/压缩/提取这些文件）。这就是我尽量避免使用它的原因。我知道你可以选择包含/不包含哪些文件，但通常你不想担心Boost与自身的交叉依赖性，所以你只需将整个库复制一份。 - bobobobo

8

我对Boost的问题是它常常依赖于几个新的库，这通常意味着需要安装更多的包才能正确地运行。我们已经需要libstdc++。例如，Boost ASIO库需要至少安装两个新的库（可能还需要更多）。使用C++11/14可以更容易地不需要Boost。 - Rahly

显示剩余5条评论