c++ map operator[]

        map 的 operator[] 不仅是简单的下标方式访问元素，还可以修改元素，甚至可以插入新元素。

1，访问元素

最简单不过的就是下标方式访问元素，类似数组的下标方式，如：

#include <iostream>
#include <map>
#include <stdio.h>
#include <string.h>
#include <string>


int main()
{  
    std::map<int, int> mInternal;
    mInternal.insert(std::pair<int, int>(0, 1));
    mInternal.insert(std::pair<int, int>(1, 2));
    mInternal.insert(std::pair<int, int>(2, 3));

    for(size_t i = 0; i < mInternal.size(); i++)
    {
        printf("%d -> %d\n", i, mInternal[i]);
    }
    return 0;
}

2，修改元素

因为这个重载操作符返回的是匹配key的元素的引用，所以可以很方便地进行元素值的修改，如：

#include <iostream>
#include <map>
#include <stdio.h>
#include <string.h>
#include <string>


int main()
{  
    std::map<int, int> mInternal;
    mInternal.insert(std::pair<int, int>(0, 1));
    mInternal.insert(std::pair<int, int>(1, 2));
    mInternal.insert(std::pair<int, int>(2, 3));

    mInternal[2] = 200;
    for(size_t i = 0; i < mInternal.size(); i++)
    {
        printf("%d -> %d\n", i, mInternal[i]);
    }
    return 0;
}

mInternal[2] = 200; 将 key=2 的值修改为了 200，结果为：

3，插入新元素

         也许有人会疑惑这个操作怎么可以插入新元素呢？我们查看 用法 后会发现，当用 [k] 操作时，如果 k 与容器中任何元素的键不匹配，该函数将插入一个具有该键的新元素，并返回对其映射值的引用。注意，这总是将容器大小增加1，即使没有为元素分配映射值(使用默认构造函数构造元素)。

#include <iostream>
#include <map>
#include <stdio.h>
#include <string.h>
#include <string>


int main()
{  
    std::map<int, int> mInternal;
    mInternal.insert(std::pair<int, int>(0, 1));
    mInternal.insert(std::pair<int, int>(1, 2));
    mInternal.insert(std::pair<int, int>(2, 3));

    mInternal[2] = 200;
    
    //会插入一个新元素，调用int的默认构造函数构造元素
    int value = mInternal[3];
    
    for(size_t i = 0; i < mInternal.size(); i++)
    {
        printf("%d -> %d\n", i, mInternal[i]);
    }
    return 0;
}

int value = mInternal[3]; 这句本来的目的是想访问 key = 3 的元素，结果意外的插入了一个新的元素，其值为0。如果是其他基本类型 float, double, char 呢？

#include <iostream>
#include <map>
#include <stdio.h>
#include <string.h>
#include <string>


int main()
{  
    std::map<int, float> mInternal;
    mInternal.insert(std::pair<int, float>(0, 1.1));
    mInternal.insert(std::pair<int, float>(1, 2.2));
    mInternal.insert(std::pair<int, float>(2, 3.3));

    mInternal[2] = 200.2;
    
    //会插入一个新元素，调用int的默认构造函数构造元素
    int value = mInternal[3];

    for(size_t i = 0; i < mInternal.size(); i++)
    {
        printf("%d -> %f\n", i, mInternal[i]);
    }

    std::map<int, char> mapChar;
    mapChar.insert(std::pair<int, float>(0, 'a'));
    mapChar.insert(std::pair<int, float>(1, 'b'));

    char ch = mapChar[2];
    for(size_t i = 0; i < mapChar.size(); i++)
    {
        printf("%d -> %c\n", i, mapChar[i]);
    }

    return 0;
}

如果是std::string类型呢？

#include <iostream>
#include <map>
#include <stdio.h>
#include <string.h>
#include <string>


int main()
{  
    std::map<int, std::string> mInternal;
    mInternal.insert(std::pair<int, std::string>(0, "1"));
    mInternal.insert(std::pair<int, std::string>(1, "2"));
    mInternal.insert(std::pair<int, std::string>(2, "3"));

    mInternal[2] = "200";
    
    //会插入一个新元素，调用int的默认构造函数构造元素
    std::string str = mInternal[3];
    
    for(size_t i = 0; i < mInternal.size(); i++)
    {
        printf("%d -> %s\n", i, mInternal[i].c_str());
    }
    return 0;
}

 

 std::string 默认构造为空字符串。

如果是自定义类型呢？

#include <iostream>
#include <map>
#include <stdio.h>
#include <string.h>
#include <string>

struct internal
{
    internal(): index(100), value(0), name("")
    {

    }
    
    internal(int i, int v, std::string s): index(i), value(v), name(s)
    {

    }
    int index;
    int value;
    std::string name;
};


int main()
{  
    internal test(1, 2, "tset");
    std::map<std::string, internal> mInternal;
    mInternal["1111"] = test;

    internal test2(2, 3, "test2");
    mInternal["2222"] = test2;
    int idx = mInternal["3333"].index; //下标访问没有对应的key时，新插入一个元素，元素调用默认构造函数生成
    printf("idx = %d\n", idx);
    
    for(auto ite : mInternal)
    {
        printf("map[%s] = %d\n", ite.first.c_str(), ite.second.index);
    }

    return 0;
}

int idx = mInternal["3333"].index; 这一句本是想获取 key = "3333" 元素的 index，却意外也插入了一个元素，而元素是调用 struct internal 的默认构造函数生成的，结果为：