Question

我有点困惑这里有一个地图名称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 ++中他们开始偏离他们的正常行为，这种行为不能有重复的密钥我无法弄清楚它是怎么回事。谁能告诉我它是怎么回事？如果问题听起来很有趣，真的很抱歉？

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

你想象一个不存在的问题。

没有＆＃34;重复的键＆＃34;。

您的容器可以这样显示：

"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]。没有什么需要被覆盖＆＃34 ;;您只是再次访问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"

我们已经访问了字符串＆＃34;名为＆＃34; myMap[1]并对其执行了操作（theString[0] = 'J'）。这对myMap没有影响。否＃34;覆盖＆＃34;需要发生。

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

Answer 2

行：

#include "stdio.h"

int main() {
  int i, j, n, A[10][10];
  n = 3;
  char *base = (char*) A;
  for (i = 0; i < n; i++)
    for (j = 0; j < n; j++) {
      char *offset0 = (char*) (&A[i][j]);
      char *offset1 = (char *) (A + j + i * 10);
      printf("%d %d %3td %3td\n", i, j, offset0 - base, offset1 - base);
    }
}

首次调用这些函数时，myMap为空。所以，

0 0   0   0
0 1   4  40
0 2   8  80
1 0  40 400
1 1  44 440
1 2  48 480
2 0  80 800
2 1  84 840
2 2  88 880

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

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

在第二个包含的地图中创建一个条目，然后分配一个＆＃39; A＆＃39;它。

然后

   myMap[1]     // XXXX

使用索引1（它本身就是一个地图）查找在XXX创建的地图条目，并将一个带有键2和值B的条目添加到第二个包含的地图。

所以我们在顶级地图中有一个条目，在第二个级别中有两个条目。

Answer 3

[]运算符执行查找并插入（如果未找到）。它将迭代器返回给定键的值。

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

然后，当myMap[1][1]返回的迭代器上调用第二个[]时，myMap[1]返回一个char的迭代器。

myMap[1][1] = 'A'和myMap[1][2] = 'B'与ourMap[1] = 'A'和ourMap[2] = 'B'没有区别。

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

3 个答案: