C++ STL容器 —— map/multimap 用法详解

写在前面：近期正在学习C++的STL容器，因此在这里做一下日志记录，主要介绍一些容器基本成员函数的用法, 配上实际用例，并不涉及原理。但别人的博客终究是别人的, 最好自己上手操作一下.
写的不好, 请大神手下留情.

下面说的 “运行之后” 表示: 运行上个语句之后的结果.
一行如果说的太长的话, 就得拖动下面的进度条才能看到后面的内容, 非常麻烦
因此将一段话分成了多行, 就像现在这种形式

C++ STL容器 —— map/multimap 用法详解
- 简介
- 构造函数
- 访问 / 赋值
- - 迭代器
  - 下标 / at
  - swap (交换函数)
- 常用函数
- 长度 / 空间 / 容量相关函数
- 添加元素
- - insert (插入函数)
  - emplace系列 (插入函数)
- 删除元素
- - erase (删除函数)
- 更改数据
- 查找数据

简介

头文件: # include < map >
容器的每个元素类型为 pair, 将 pair 的第一部分作为键(key), 第二部分作为值(value), key 具有容器set的特点: 有序性, 每个 key 都有一个 value 对应, 而 value没有什么限制
会根据特定的排序标准，自动将元素进行排序。容器内的元素一直是有序的. 默认使用升序排序.
map和multimap的区别
map: 容器中 key 只能存在一个, 支持随机访问
multimap: 容器 key 可以存在多个, 不支持随机访问
其他用法都相同.

点击前往: pair 用法详解
点击前往: set/multiset 用法详解

构造函数

map <int, string> m, m1;
//定义 [int,string] 类型的map容器multimap <int, string> mm, mm1;
//定义 [int,string] 类型的multimap容器map <char, int> mchi;
//定义 [char,int] 类型的容器map <string, int> mstri;
//定义 [string,int] 类型的容器map <int, string> m3{ {1,"aaa"}, {2,"bbb"},{3,"ccc"} };
//赋值map <int, string> m4 = { {1,"aaa"}, {2,"bbb"},{3,"ccc"} };
//同上map <int, string> m5(m);
//定义新容器, 拷贝 m 所有的元素map <int, string> m6(m.begin(), m.end());
//定义新容器, 拷贝 m 区间内所有的元素map <int, string, greater<int> > m7;
//排序准则为降序map <int, string, op > m8;
//排序准则为 op

访问 / 赋值

迭代器

分为：begin、end、rbegin、rend、cbegin、cend、crbegin、crend
使用方法:

auto it=m.begin(); //相当于指针，用 *it 访问

m.begin(); 返回迭代器, 指向第一元素
m.end(); 返回迭代器, 指向最末元素的下一个位置
m.cbegin(); 返回迭代器, 指向第一元素, 类型为const
m.rbegin(); 返回反向迭代器, 指向反向迭代的第一元素
m.rend(); 返回反向迭代器, 指向反向迭代的最末元素的下一个位置
m.crbegin(); 返回反向迭代器, 指向反向迭代的第一元素, 类型为const

例: 使用正向遍历 m 数组

map <int, int> m{ {1,11},{2,22},{3,33} };
for (auto it = m.begin(); it != m.end(); it++) {//注意这里是不等于end, 而不是小于endcout << it->first << ' ' << it->second << endl;
}输出结果为:
1 11
2 22
3 33

例: 反向遍历 m 数组

map <int, int> m{ {1,11},{2,22},{3,33} };
for (auto it = m.rbegin(); it != m.rend(); it++) {//注意这里还是it++, 而不是it--cout << it->first << ' ' << it->second << endl;
}
输出结果为:
3 33
2 22
1 11

begin和rbegin的区别
m.begin()返回迭代器，指向容器内的第一元素
m.rbegin()返回逆序迭代器，指向容器内的最后一个元素

begin和cbegin的区别
可以通过m.begin()修改容器内元素的值
不能通过m.cbegin()修改容器内元素的值

下标 / at

可以使用下标 [] 和 at 函数随机访问, 并不一定是数字, 这种方式只适合map
例: m = { {1,“aaa”}, {2,“bbb”},{3,“ccc”} };
则: m[2]=m.at(2)=”bbb”
例: mstri = { { “aaa”,1 }, { “bbb”,a }, { “ccc”,3 } };
则: mstri[“bbb”]=mstri.at(“bbb”)=2;

swap (交换函数)

m.swap(m1);
//交换两个容器的内容
//例:m={ {1,11},{2,22} }, m1={ {3,33},{4,44} }
//运行之后, m={ {3,33},{4,44} }, m1={ {1,11},{2,22} }

常用函数

m.clear();
//清空容器m.empty();
//容器为空返回 true, 否则返回 false

长度 / 空间 / 容量相关函数

m.size();
//返回容器目前的元素个数
//例:m={ {1,11},{2,22} }
//返回 2m.max_size();
//返回元素个数 size 的最大值

添加元素

insert (插入函数)

m.insert({ 4,"ddd" });
//插入元素 {4,"ddd"}, map: 如果重复, 此语句不执行
//例:m={ {1,"aa"},{2,"bb"} }
//执行之后: m={ {1,"aa"},{2,"bb"},{4,"ddd"} }
//例:m={ {1,"aa"},{2,"bb"},{4,"ddd"} }
//执行之后: m={ {1,"aa"},{2,"bb"},{4,"ddd"} }m.insert(m.begin(), { 4,"ddd" });
//在位置之后插入元素 {4,"ddd"}, 用的不多, 指定位置之后还要排序
//例:m={ {1,"aa"},{2,"bb"} }
//执行之后: m={ {1,"aa"},{2,"bb"},{4,"ddd"} }
//例:m={ {1,"aa"},{2,"bb"},{4,"ddd"} }
//执行之后: m={ {1,"aa"},{2,"bb"},{4,"ddd"} }m.insert(m1.begin(), m1.end());
//插入 m1 区间所有的元素
//例:m={ {1,11},{2,22} }, m1={ {3,33},{4,44} }
//运行之后, m={ {1,11},{2,22},{3,33},{4,44} }
//例:m={ {1,11},{2,22},{3,33} }, m1={ {3,33},{4,44} }
//运行之后, m={ {1,11},{2,22},{3,33},{4,44} }

emplace系列 (插入函数)

m.emplace(pair <int, string> {4, "ddd"});
//插入元素 {4,"ddd"}
//例:m={ {1,"aa"},{2,"bb"} }
//执行之后: m={ {1,"aa"},{2,"bb"},{4,"ddd"} }
//例:m={ {1,"aa"},{2,"bb"},{4,"ddd"} }
//执行之后: m={ {1,"aa"},{2,"bb"},{4,"ddd"} }m.emplace_hint(m.begin(), pair <int, string>{4, "ddd"});
//在位置之后插入元素 {4,"ddd"}, 用的不多, 指定位置之后还要排序
//例:m={ {1,"aa"},{2,"bb"} }
//执行之后: m={ {1,"aa"},{2,"bb"},{4,"ddd"} }
//例:m={ {1,"aa"},{2,"bb"},{4,"ddd"} }
//执行之后: m={ {1,"aa"},{2,"bb"},{4,"ddd"} }

删除元素

erase (删除函数)

m.erase(3);//删除 key 为 3 的元素
//例:m={ {1,"aa"},{2,"bb"},{3,"cc"} }
//执行之后: m={ {1,"aa"},{2,"bb"} }
//例:m={ {1,"aa"},{2,"bb"} }
//执行之后: m={ {1,"aa"},{2,"bb"} }m.erase(m.begin());//删除指向的元素
//例:m={ {1,"aa"},{2,"bb"},{3,"cc"} }
//执行之后: m={ {2,"bb"},{3,"cc"} }m.erase(m.begin(), m.end());//删除区间内所有的元素
//例:m={ {1,"aa"},{2,"bb"},{3,"cc"} }
//执行之后: m={}

更改数据

可以使用 key 随机访问并更改 value
例: m[“aaa”]=3; 或者 m.at(“aaa”)=3;

查找数据

容器内部元素有序, 因此查找时采用二分.

m.count(3);//返回 key 为 3 的元素个数
//例:m={ {1,"aa"},{2,"bb"},{3,"cc"} }
//返回 1
//例:m={ {1,"aa"},{2,"bb"} }
//返回 0m.find(3);
//返回迭代器, 指向 key 值为 3 的第一个元素, 如果没有就返回 end()
//例:m={ {1,"aa"},{2,"bb"},{3,"cc"} }
//返回指向{3,"cc"}的迭代器
//例:m={ {1,"aa"},{2,"bb"} }
//返回end()
//例:mm={ {1,"aa"},{2,"bb"},{3,"cc"},{3,"cc"} }
//返回指向第一个{3,"cc"}的迭代器m.lower_bound(3);
//返回迭代器, 指向 key 值>=3 的第一个元素的位置
//例:m={ {1,"aa"},{2,"bb"},{3,"cc"},{4,"dd"} }
//返回指向{3,"cc"}的迭代器
//例:m={ {1,"aa"},{2,"bb"},{4,"dd"} }
//返回指向{4,"dd"}的迭代器
//例:mm={ {1,"aa"},{2,"bb"},{3,"cc"},{3,"cc"},{4,"dd"} }
//返回指向第一个{3,"cc"}的迭代器m.upper_bound(3);
//返回迭代器, 指向 key 值>3 的第一个元素的位置
//例:m={ {1,"aa"},{2,"bb"},{3,"cc"},{4,"dd"} }
//返回指向{4,"dd"}的迭代器
//例:m={ {1,"aa"},{2,"bb"},{4,"dd"} }
//返回指向{4,"dd"}的迭代器
//例:mm={ {1,"aa"},{2,"bb"},{3,"cc"},{3,"cc"},{4,"dd"} }
//返回指向{4,"dd"}的迭代器m.equal_range(3);
//返回 pair 容器: [m.lower_bound(3), m.upper_bound(3)]
//例:m={ {1,"aa"},{2,"bb"},{3,"cc"},{4,"dd"} }
//返回pair{指向{3,"cc"}的迭代器, 指向{4,"dd"}的迭代器}