C++ STL中map的[]操作符使用时的一个坑

发表于 | 更新于 | 分类于 |
热度 ℃   |   字数统计: 1,660(字)   |   阅读时长: 7(分) |

前言

学习C++，自从发现了map这个结构以后，就深深的被这种键值对的方式吸引了，写代码时也渐渐离不开这种结构了，一次偶然的机会发现这个map还有个 [] 运算符，仿佛又发现了新大陆一样，写代码更加方便了，殊不知一个深深的大坑正在前面等着我。

问题

一开始学到map的时候还是中规中矩的使用函数插入删除，比如定义一个map，先引入头文件和命名空间：

1
2
3
4
#include <map>
using namespace std;

map<int, int> mapTest;

上面就轻松定义了一个map结构对象，是一个整数到另一个整数的映射，这种映射有什么用呢？举个简单的例子，这个映射可以作为学生的学号和成绩的对应关系，这样只要知道学号，就可以从map中直接获得对应的成绩很方便。

最开始学习插入时通常有以下两种方式：

1
2
mapTest.insert(map<int, int>::value_type(1001, 100));
mapTest.insert(make_pair(1002, 98));

但是学了 map 的 [] 操作符以后，上述代码可以写成：

1
2
mapTest[1001] = 100;
mapTest[1002] = 98;

查找一个元素的时候需要用到find()函数，一般写成

1
2
3
map<int, int>::const_iterator itor = mapTest.find(1001);
if (itor != mapTest.end())
    return itor->second;

但是学了 map 的 [] 操作符以后，上述代码就可以简写成：

1
return mapTest[1001];

特别的在插入一个元素的时候，比如用来计数，每次给一个键对应的值加1时，可以直接写成：

1
mapTest[1001] += 1;

根本不用检查 1001 这个键是否存在，使用 [] 操作符，在使用前会先默认成0，然后执行+1操作，这个比先使用find()查找，然后+1操作后再插入方便多了。

其实这只是使用map结构的一种语法糖，但是这语法糖简直太好使了，太甜了，让人欲罢不能，所以我就含着这块糖掉进了坑里，因为调用 map 的有时会产生副作用，如果查找一个键不在 map 中，则会在map中对应的这个键的位置插入默认值，接下来看一下例子就明白了。

测试过程

测试代码在VS2015中编译运行，C++11标准，如果编译不正确可以看一下环境是否不同，尝试修改代码实现即可，测试的例子也是上面提到的，使用 map 来存储学生学号和成绩的对应关系，下面来简单实现一个类，描述这种关系：

编写测试类

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
#include <map>
#include <iostream>
#include <algorithm>
using namespace std;

class CReportCard
{
public:
    CReportCard() { m_mapStuNo2Score.clear(); }
    ~CReportCard() { m_mapStuNo2Score.clear(); }
public:
    void LoadScores(); // 模拟录入成绩
    int  GetScoreByStudentNo(const int nStudentNo); // 根据学号查询成绩
    void PrintReportCard(); // 打印成绩单
private:
    map<int, int> m_mapStuNo2Score;
};

void CReportCard::LoadScores()
{
    m_mapStuNo2Score[1001] = 99;
    m_mapStuNo2Score[1002] = 94;
    m_mapStuNo2Score[1004] = 89;
    m_mapStuNo2Score[1005] = 92;
    m_mapStuNo2Score[1007] = 80;
}

int CReportCard::GetScoreByStudentNo(const int nStudentNo)
{
    return m_mapStuNo2Score[nStudentNo];
}

void CReportCard::PrintReportCard()
{
    cout << "show report card start----->" << endl;
    std::for_each(m_mapStuNo2Score.begin(), m_mapStuNo2Score.end(), [](std::map<int, int>::reference socrepair)
    {
        std::cout << socrepair.first << "'s score = " << socrepair.second << "\n";
    });
    cout << "show report card end<------" << endl;
}

这个类的内容很简单，使用 map 类型的对象 m_mapStuNo2Score 来存储学号和成绩的对应关系，LoadScores()函数中使用 [] 操作符向 map 中插入元素，模拟成绩录入过程；GetScoreByStudentNo()函数同样使用了 [] 操作符模拟成绩查询过程；PrintReportCard()函数遍历 map 打印成绩单信息。

看似正常的调用

接下来编写一个函数来使用这个类，测试如下：

1
2
3
4
5
6
7
8
9
10
11
12
int main(int argc, char* argv[])
{
    CReportCard obj;
    obj.LoadScores();

    cout << "student no = 1001, score = " << obj.GetScoreByStudentNo(1001) << endl;
    cout << "student no = 1004, score = " << obj.GetScoreByStudentNo(1004) << endl;

    obj.PrintReportCard();

    return 0;
}

首先调用 LoadScores()函数来加载数据，然后通过 GetScoreByStudentNo() 函数来查找学号为 1001 和 1004 的两个学生的成绩，最后打印一下成绩单，接下来看一下运行结果：

student no = 1001, score = 99
student no = 1004, score = 89
show report card start—–>
1001’s score = 99
1002’s score = 94
1004’s score = 89
1005’s score = 92
1007’s score = 80
show report card end<——

以上结果正常的打印出了查询的分数和成绩单，一切看起来毫无问题，如果查询的学号不存在又会怎么样呢？

出现问题的调用

修改上面的测试函数，将学生学号改成不存在的数值，修改如下：

1
2
3
4
5
6
7
8
9
10
11
12
13
int main(int argc, char* argv[])
{
    CReportCard obj;
    obj.LoadScores();

    cout << endl;
    cout << "student no = 1011, score = " << obj.GetScoreByStudentNo(1011) << endl;
    cout << "student no = 1014, score = " << obj.GetScoreByStudentNo(1014) << endl;

    obj.PrintReportCard();

    return 0;
}

大部分的内容并没有发生变化，只将学号改成了不存在的情况，测试结果如下：

student no = 1011, score = 0
student no = 1014, score = 0
show report card start—–>
1001’s score = 99
1002’s score = 94
1004’s score = 89
1005’s score = 92
1007’s score = 80
1011’s score = 0
1014’s score = 0
show report card end<——

不存在的学号对应的分数是0，这应该也说的过去，因为键不存在，所以对 map 使用 [] 操作符查找时，寻找的键不存在则返回了整型的默认值0，但是在打印成绩单的时候居然多了两项，这充分暴露了 [] 操作符可能产生的副作用。

在查找返回时，[] 操作符并不是找不到返回对应类型默认值就完了，还会把查找的键和默认值作为一对，插入到待查的 map，这种操作一般是我们不需要的，所以在你明确不需要这个副作用时，查找 map 元素不要使用 [] 操作符。

亡羊补牢

上面说到，[] 操作符查找不到就插入的副作用一般我们不使用，所以在查找时还是使用 find() 函数更规范一些，修改 GetScoreByStudentNo() 函数如下：

1
2
3
4
5
6
int CReportCard::GetScoreByStudentNo(const int nStudentNo)
{
    //return m_mapStuNo2Score[nStudentNo];
    map<int, int>::const_iterator itor = m_mapStuNo2Score.find(nStudentNo);
    return itor != m_mapStuNo2Score.end() ? itor->second : 0;
}

此时再运行上面的例子就正常了，成绩单中也不会插入无效值了。

总结

  1. map 的 [] 操作符会有副作用，当查找的键不存在时，会在对应键位置插入默认值
  2. 时刻保持清醒的头脑，过分的方便或许会给你自己埋下深深的坑
  3. 敬畏自然、敬畏生命、敬畏你写下的每一行代码
Albert Shi wechat
欢迎您扫一扫上面的微信公众号，订阅我的博客