在C++中映射内部地图。很混乱？

Question

我有点困惑这里有一个地图名称myMap是一个地图里面的地图 明显在价值方面，而第二个地图是 非常正常的地图的int与字符。 没有在一种情况下（这是我的地图）它允许 重复键（异常行为），而在另一种情况下它不允许。

#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++他们开始从他们的正常行为是不能有重复键 我无法弄清楚它是如何如此偏离。谁能告诉我这是怎么回事？非常抱歉，如果这个问题听起来很有趣？

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 . 

Answer 1

如果找不到，[]操作符会执行查找并插入。它将一个迭代器返回给定一个键的值。

因此，执行myMap [1]会将迭代器返回给地图。

然后，在从myMap [1]返回的迭代器上调用myMap [1] [1]时，会将一个迭代器返回给char。我的地图[1] [1] ='A'和myMap [1] [2] ='B'与我们的地图[1] ='A'和我们的地图[2] ='B'没有什么不同。 。

Answer 2

OK：

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

当这些功能被先叫，MYMAP是空的。所以，

myMap[1]  // XXXX 

创建在地图索引条目：1.创建的东西本身就是一张地图。然后：

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

在第二个包含的地图中创建一个条目，并为其分配“A”。

然后

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

仰视XXX具有索引1（其本身是一个地图）创建的映射条目，并增加了与键2和值B到第二入口中，包含地图。

因此，我们在顶层地图中有一个条目，第二个层次中有两个条目。

Answer 3

你在想象一个没有存在的问题。

没有“重复密钥”。

您的容器可由此显现：

"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]，您访问内部地图的关键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没有影响。不需要“覆盖”。

当你嵌套一个地图时，它没有什么不同。