C++ c+的速记语法+；地图中的地图

如果我有如下定义：

typedef map<string, Foo> Foo_map_1
typedef map<string, Foo_map_1> Foo_map_2
typedef map<string, Foo_map_2> Foo_map_3
typedef map<string, Foo_map_3> Foo_map_4
typedef map<string, Foo_map_4> Foo_map_5

typedef映射Foo\u映射1
类型定义映射Foo_映射2
类型定义映射Foo_映射3
类型定义映射Foo_映射4
类型定义映射Foo_映射5

我能概括一下吗，比如说

Foo_map<10>

Foo_地图

并有一个10倍嵌套的地图。我不需要类似于

boost:：recursive\u wrapper

的东西，因为级别的数量总是恒定的。

这对我很有用

#include <iostream>
#include <string>
#include <map>
using namespace std;

struct Foo
{
   Foo() : _in(0) {}
   Foo(int in) : _in(in) {}
   int _in;
};

template <int N> struct Foo_map
{
   map<string, Foo_map<N-1> > foo_Map;
   Foo_map<N-1>& operator[](string const& key) { return foo_Map[key]; }
};

template <> struct Foo_map<1>
{
   map<string, Foo> foo_Map;
   Foo& operator[](string const& key) { return foo_Map[key]; }
};

int main()
{
   Foo_map<1> map1;
   map1["abcd"] = Foo(10);

   Foo_map<2> map2;
   map2["a"]["b"] = Foo(20);

   Foo_map<10> map10;
   map10["a"]["b"]["c"]["d"]["e"]["f"]["g"]["h"]["i"]["j"] = Foo(100);

   std::cout << map1["abcd"]._in << std::endl;
   std::cout << map2["a"]["b"]._in << std::endl;
   std::cout << map10["a"]["b"]["c"]["d"]["e"]["f"]["g"]["h"]["i"]["j"]._in << std::endl;
}

#包括
#包括
#包括
使用名称空间std；
结构Foo
{
Foo（）：_在（0）{}
Foo（int-in）：_-in（in）{
int_in；
};
模板结构Foo_映射
{
地图富奥图；
Foo_映射和运算符[]（字符串常量和键）{return Foo_映射[key]；}
};
模板结构Foo_映射
{
地图富奥图；
Foo&运算符[]（字符串常量和键）{返回Foo_映射[key]；}
};
int main（）
{
福乌地图1；
map1[“abcd”]=Foo（10）；
福乌地图2；
map2[“a”][“b”]=Foo（20）；
福乌地图10；
map10[“a”][“b”][“c”][“d”][“e”][“f”][“g”][“h”][“i”][“j”]=Foo（100）；
STD：：CUT
这似乎是足够容易的，即使对于有限的C++元编程能力：
#include <map>
#include <string>

template<int N, typename K, typename V>
struct NMap { typedef std::map<K, typename NMap<N-1, K, V>::type> type; };

template<typename K, typename V>
struct NMap<1, K, V> { typedef std::map<K, V> type; };

int main(int argc, const char *argv[]) {
    NMap<3, int, std::string>::type m;
    m[1][2][3] = "Test";
    return 0;
}

#包括
#包括
模板
结构NMap{typedef std:：map type；}；
模板
结构NMap{typedef std:：map type；}；
int main（int argc，const char*argv[]{
NMap：：类型m；
m[1][2][3]=“测试”；
返回0；
}
你能解释一下使用2种结构背后的逻辑吗？@sameerkarjatkar：一种是将N-map映射成从键映射到（N-1）映射的映射的通用模板。另一种是结束N=1情况下递归的模板专门化（否则模板递归将是无限的）。需要该结构，因为C++03没有“template typedef”和执行此类类型计算的标准解决方法是使用仅包含typedef.IOW的模板结构，如果您的编译器是适度最新的，则不再需要这些结构。@m可选：C++03限制并不重要（只要求您添加
：：type
）。OTOH C++11别名（据我所知，这就是“解决方案”）不允许部分专门化，在我看来这是一个更严重的问题。@6502:好吧，你可以别名部分专门化，但不能部分专门化别名。因此，你肯定可以别名你的
NMap:：type
。但是你也有
std:：conditional:：type
，它可以取代部分专门化。
#include <map>
#include <string>

template<int N, typename K, typename V>
struct NMap { typedef std::map<K, typename NMap<N-1, K, V>::type> type; };

template<typename K, typename V>
struct NMap<1, K, V> { typedef std::map<K, V> type; };

int main(int argc, const char *argv[]) {
    NMap<3, int, std::string>::type m;
    m[1][2][3] = "Test";
    return 0;
}