C++，我可以在编译时静态初始化 std::map 吗？

Question

如果我编码这个

std::map<int, char> example = {
                                (1, 'a'),
                                (2, 'b'),
                                (3, 'c') 
                              };

然后g++对我说

deducing from brace-enclosed initializer list requires #include <initializer_list>
in C++98 ‘example’ must be initialized by constructor, not by ‘{...}’   

这让我有点恼火，因为构造函数是运行时的，理论上可能会失败。

当然，如果确实如此，它会很快失败，并且应该始终如一地这样做，因此我应该快速定位并纠正问题。

但是，我仍然很好奇 - 是否有在编译时初始化地图、矢量等？

---

编辑：我应该说我正在为嵌入式系统开发。并非所有处理器都有 C++0x 编译器。最受欢迎的可能会，但我不想遇到问题并且必须维护 2 个版本的代码。

至于 Boost，我还没有决定。他们对在嵌入式系统中使用他们的有限状态机类持怀疑态度，所以这实际上是我在这里编码的，事件/状态/Fsm 类。

唉，我想我最好还是谨慎行事，但我希望这次讨论对其他人有所帮助。

Answer 1

这并不完全是静态初始化，但仍然可以尝试一下。 如果你的编译器不支持 C++0x，我会选择 std::map 的迭代构造函数：

std::pair<int, std::string> map_data[] = {
    std::make_pair(1, "a"),
    std::make_pair(2, "b"),
    std::make_pair(3, "c")
};

std::map<int, std::string> my_map(map_data,
    map_data + sizeof map_data / sizeof map_data[0]);

这非常易读，不需要任何额外的库，并且应该适用于所有编译器。

Answer 2

在 C++98 中没有。 C++11 支持这一点，所以如果你启用 C++11 标志并包含 g++ 建议的内容，你可以。

编辑：从 gcc 5 C++11 默认开启

Answer 3

你可以使用Boost.Assign库：

#include <boost/assign.hpp>
#include <map>
int main()
{
   std::map<int, char> example = 
      boost::assign::map_list_of(1, 'a') (2, 'b') (3, 'c');
}

然而，正如 Neil 和其他人在下面的 cmets 中指出的那样，这种初始化发生在运行时，类似于 UncleBean 的提议。

Answer 4

对于 C++0x，您可能需要一直使用大括号（也为每一对使用新式语法）：

std::map<int, char> example = { {1,'a'}, {2, 'b'}, {3, 'c'} };

那些构造对的括号没有意义。或者，您可以完全命名每一对或使用 make_pair（就像在 C++98 中所做的那样）

std::map<int, char> example = {
    std::make_pair(1,'a'),
    std::make_pair(2, 'b'),
    std::make_pair(3, 'c')
};

关于在编译时创建这些实例：不。 STL 容器都完全封装了运行时内存管理。

我想，你真的只有一个编译时映射，其中包含诸如 boost 的元编程之类的库（不是 100% 肯定，如果它完全正确，并且还没有研究它可能有什么用处）：

using namespace boost::mpl;
map<
    pair<integral_c<int, 1>, integral_c<char, 'a'> >,
    pair<integral_c<int, 2>, integral_c<char, 'b'> >,
    pair<integral_c<int, 3>, integral_c<char, 'c'> >
> compile_time_map;

Answer 5

对于 C++0x 之前的版本，最接近的方法是不使用为运行时使用而设计的容器（并将自己限制在基本类型和聚合中）：

struct pair { int first; char second; };
pair arr[] = {{1,'a'}, {2,'b'}}; // assuming arr has static storage

然后可以使用某种地图视图来访问它，或者您可以实现一个允许聚合初始化的包装器，类似于Boost.Array 所做的。

当然，问题是这些好处是否证明投入时间来实施这一点是合理的。

如果我在这里的阅读是正确的，C++0x 初始化器列表可能为您提供非聚合的静态初始化，例如 std::map 和 std::pair，但前提是这不会改变语义与动态初始化相比。
因此，在我看来如果你的实现可以通过静态分析验证如果 map 被静态初始化，行为不会改变，你只能得到你所要求的，但不能保证它发生。

Answer 6

您可以使用一个技巧，但前提是此数据不会在任何其他静态构造函数中使用。 首先定义一个像这样的简单类：

typedef void (*VoidFunc)();
class Initializer
{
  public:
    Initializer(const VoidFunc& pF)
    {
      pF();
    }
};

然后，像这样使用它：

std::map<std::string, int> numbers;
void __initNumsFunc()
{
  numbers["one"] = 1;
  numbers["two"] = 2;
  numbers["three"] = 3;
}
Initializer __initNums(&__initNumsFunc);

当然，这有点矫枉过正，所以我建议您仅在确实需要时才使用它。

Answer 7

没有在编译时初始化std::map 的标准方法。正如其他人所提到的，C++0x 将允许编译器尽可能将初始化优化为静态，但这永远无法保证。

但请记住，STL 只是一个接口规范。您可以创建自己的兼容容器并为其提供静态初始化功能。

根据您是否计划升级编译器和 STL 实现（尤其是在嵌入式平台上），您甚至可以深入研究您正在使用的实现，添加派生类并使用它们！

Answer 8

template <const int N> struct Map  { enum { value = N}; };
template <> struct Map <1> { enum { value = (int)'a'}; };
template <> struct Map <2> { enum { value = (int)'b'}; };
template <> struct Map <3> { enum { value = (int)'c'}; };

std::cout  << Map<1>::value ;