在 C++ 中映射内部映射。相当混乱？答案

【问题标题】：map inside map in C++ . Pretty confusing?在 C++ 中映射内部映射。相当混乱？
【发布时间】：2017-05-04 20:51:50
【问题描述】：

我在这里有点困惑，一张名为 myMap 的地图是地图内的地图显然在价值方面，而第二张地图是非常正常的 int vs char 映射。不允许在一种情况下（即 myMap）重复键（异常行为），而在另一种情况下则没有。

#include <iostream>
#include <map> 
using namespace std;
int main(void)
{ 
    map<int, map<int,char> > myMap;   // map inside map
    map<int, char> ourMap;            // normal map

    myMap[1][1] = 'A';
    myMap[1][2] = 'B';     // should overwrite  previous value
    myMap[2][1] = 'C';
    myMap[2][2] = 'D';     // should overwrite  previous value

    ourMap[1] = 'A';
    ourMap[1] = 'B';

    cout << "[1][1] = " << myMap[1][1] << endl;
    cout << "[1][2] = " << myMap[1][2] << endl;
    cout << "[2][1] = " << myMap[2][1] << endl;
    cout << "[2][2] = " << myMap[2][2] << endl;

    cout << "ourMap[1] = " << ourMap[1] << endl;

    return 0;
}
// And here is the output . By the way I was anticipating , [1][2] = B , [2][2] = D & ourMap[1] = B . But something else comes out . 

OUTPUT :

[1][1] = A
[1][2] = B
[2][1] = C
[2][2] = D
ourMap[1] = B

如果我们在 C++ 中的 map 里面有 map，它们会开始偏离它们的正常行为，即不能有重复的键我无法弄清楚它是怎么回事。谁能告诉我这是怎么回事？如果这个问题听起来很有趣，非常抱歉？

My Question is for myMap 
myMap[x][y] = something
u can have only distinct value of x ?
For normal map it is like that only .

【问题讨论】：

请放心，不会发生密钥重复或异常行为
"myMap[1][2] = 'B'; // 应该覆盖之前的值" - 为什么？
为什么你认为myMap[1][2] = 'B' 应该覆盖myMap[1][1] = 'A'？
我的问题是针对 myMap myMap[x][y] = 你只能有不同的 x 值吗？对于法线贴图，仅此而已。
只有一个 x 的不同值。

标签： c++ dictionary stl

【解决方案1】：

您正在想象一个不存在的问题。

没有“重复键”。

您的容器可以这样显示：

"myMap"                              map<int, map<int,char>>
  |
  +-- [1]  "myMap[1]"                map<int,char>
  |          |
  |          +-- [1]  "myMap[1][1]"  char
  |          |
  |          +-- [2]  "myMap[1][2]"  char
  |
  +-- [2]  "myMap[2]"                map<int,char>
             |
             +-- [1]  "myMap[2][1]"  char
             |
             +-- [2]  "myMap[2][2]"  char

在这一行：

myMap[1][1] = 'A';

你访问（并且，因为它还不存在，所以创建）myMap[1]。

然后，使用myMap[1]，您访问inner 映射的键1 并分配'A'。

接下来，在这一行：

myMap[1][2] = 'B';

您再次访问myMap[1]。没有什么需要被“覆盖”；您只是再次访问myMap[1] 中的第一个元素。

这一次，您访问内部映射的键 2 并分配 'B'。

这是编写代码的另一种方式，使用引用为这些内部映射获取更清晰的名称：

map<int,char>& firstInnerMap = myMap[1];
firstInnerMap[1] = 'A';
firstInnerMap[2] = 'B';

map<int,char>& secondInnerMap = myMap[2];
secondInnerMap[1] = 'C';
secondInnerMap[2] = 'D';

或者，考虑map<int, string>：

map<int, string> myMap;
myMap[1] = "Hello";
myMap[1][0] = 'J';   // change string to "Jello"

我们访问了字符串“被调用”myMap[1] 并对其执行了操作 (theString[0] = 'J')。这对myMap 没有影响。不需要发生“覆盖”。

当您嵌套地图时，它没有什么不同。

【讨论】：

【解决方案2】：

好的：

   myMap[1][1] = 'A';

当这些函数第一次被调用时，myMap 是空的。所以，

   myMap[1]     // XXXX

在该映射中创建一个索引为 1 的条目。创建的东西本身就是一个映射。那么：

   myMap[1][1] = 'A';

在第二个包含的映射中创建一个条目，并将“A”分配给它。

然后

     myMap[1][2] = 'B';

查找在 XXX 处创建的索引为 1 的映射条目（它本身就是一个映射），并将键为 2 且值为 B 的条目添加到第二个包含映射的条目。

所以我们在顶层映射中有一个条目，在第二级映射中有两个条目。

【讨论】：

【解决方案3】：

[] 运算符执行查找并在未找到时插入。它返回一个给定键的值的迭代器。

因此执行myMap[1] 会将迭代器返回到map<int,char>。

然后执行myMap[1][1] 将迭代器返回到一个字符，因为第二个[] 正在从myMap[1] 返回的迭代器上被调用。

所以myMap[1][1] = 'A' 和myMap[1][2] = 'B' 与ourMap[1] = 'A' 和ourMap[2] = 'B' 没有什么不同。

【讨论】：