关联式容器

是一只小兔兔！

已于 2023-01-05 20:52:48 修改

阅读量1.5k

点赞数 2

分类专栏： stl 文章标签： c++

于 2022-01-19 22:36:35 首次发布

本文链接：https://blog.csdn.net/m0_53063591/article/details/122591483

版权

stl 专栏收录该内容

5 篇文章 2 订阅

订阅专栏

关联式容器

概念

STL关联式容器的提出，主要是为了解决序列式容器查找、删除、读取慢的问题。并且关联式容器的插入往往其底层的实现相比序列式容器更为快捷。

关联式容器相比于序列式容器，其在存储时除了存储数据本身，还会额外存储一个名为“键”的结构，其额外存储一个键的目的，就是为了能够凭借这个键，实现对元素的快速查找。

关联式容器存储的元素，都是一个一个的“键值对”（ <key,value> ），除此之外，序列式容器中存储的元素默认都是未经过排序的，而使用关联式容器存储的元素，默认会根据各元素的键值的大小做升序排序。

内容

常用的关联式容器通常包括如下容器：

pair	一个可以是由两个不同的类型T1，T2组成的二元组
map	该容器存储以T1类型为键，T2类型为数据的元素，其各个元素的键必须是唯一的（即不能重复），该容器会根据各元素键的大小，默认进行升序排序（调用 std::less）。
set	使用该容器存储的数据，各个元素键和值完全相同，且各个元素的值不能重复（保证了各元素键的唯一性）。该容器会自动根据各个元素的键（其实也就是元素值）的大小进行升序排序（调用 std::less）
multimap	和 map 容器唯一的不同是multimap 容器中存储元素的键可以重复
multiset	和 set 容器唯一的不同是multiset 容器中存储元素的值可以重复（一旦值重复，则意味着键也是重复的）

关联式容器迭代器的通用函数

由于关联式容器都支持双向迭代器，关联式容器支持的操作符包括++p,p++,–p,p–,*p,==和!=,并且对于任意一个关联式容器都支持如下八个操作

begin()	返回指向第一个元素的双向迭代器
end()	返回指向容器最后一个元素之后一个位置的双向迭代器
rbegin()	返回指向最后一个元素的双向迭代器
rend()	返回指向第一个元素之前一个位置的双向迭代器
cbegin()	和 begin() 功能相同，只不过在其基础上增加了 const 属性，不能用于修改元素
cend()	和 end() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素
crbegin()	和 rbegin() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素
crend()	和 rend() 功能相同，只不过在其基础上，增加了 const 属性，不能用于修改元素

注意，关联式容器无法使用sort进行排序

关联式容器用法

pair

考虑到<key,value>键值对这一特殊形式，STL封装了一个名为pair的模板，其包括first和second两个元素形成一个二元组<first, second>

定义在头文件<utility>中，使用需要:

#include<utility>
using namespace std;

定义

定义一个pair存在多种方法，但最常用的还是这几种：

1.定义一个空pair
pair<T1,T2> p;
2.调用构造函数
pair<T1,T2> p(first,second);
3.调用拷贝构造函数
pair<T1,T2> p2(p1);
4.调用移动构造函数
pair<T1,T2> p(make_pair(first,second));
5.调用右值引用
pair<T1,T2> p((T1)first,(T2)second);
6.初始化成员列表
pair<T1,T2> p{first,second};或pair<T1,T2> p = {first,second};
    
pair<int,int> p;//一个空pair，其first和second默认初始化为0
cout << p.first << ' ' << p.second << endl;//0 0
pair<string, string> p2("stl", "yyds");
cout << p2.first << ' ' << p2.second << endl;//stl yyds
pair<int, int> p3(1, 2);
pair<int, int> p4(p3);
cout << p4.first << ' ' << p4.second << endl;//1 2
pair<string, string> p5(make_pair("hello", "world"));
cout << p5.first << ' ' << p5.second << endl;//hello world
pair<string, string> p6((string)"happy", (string)"day");
cout << p6.first << ' ' << p6.second << endl;//happy day

除了上面列出的方法，pair还允许直接对first、second属性赋值

成员函数

pair允许对pair对象进行比较操作，包括> < >= <= == !=在比较时，首先比较first元素，然后再比较second元素。注意在比较的时候两个pair的T1与T2类型要严格一致，其不支持自动类型转换

pair<int, int> p(0, 0);
pair<double, double> p2('0','1');
if (p < p2) {//error
    cout << 1;
}

map

map一般存储的都是pair对象，当存储多个键值对时，该容器会自动根据各键值对的键的大小，按照既定的规则进行排序。默认情况下，map 容器选用std::less<T>排序规则。除此之外，我们可以手动指定 map 容器的排序规则，既可以选用 STL 标准库中提供的其它排序规则（比如std::greater<T>），也可以自定义排序规则。

另外，对于map容器来说，其键（key）是一个被加了const修饰的值，不能被修改，更不能重复，但是value是一个可以被修改的值，并且多个key可以同时对应一个value

定义在<map>头文件中，使用需要

#include <map>
using namespace std;

定义

一个map容器的定义如下：

template < class Key,                                     // 指定键（key）的类型
           class T,                                       // 指定值（value）的类型
           class Compare = less<Key>,                     // 指定排序规则
           class Alloc = allocator<pair<const Key,T> >    // 指定分配器对象的类型
           > class map;

多数情况下我们只要指定前两个，即key与value，有时候根据需要还可以指定map容器的比较方法。

创建以及初始化map容器：

*下列初始化都会给出默认排序，实际中可以不写，默认调用std::less<T1>，可以根据需要编写自定义的比较
1.直接创建一个空的map
map<T1,T2,std::less<T1>> m;
2.初始化成员列表
map<T1,T2,std::less<T1>> m{{key1,value1},{key2,value2}...};
3.借助pair的移动构造函数
map<T1,T2,std::less<T1>> m{std::make_pair({key1,value1}),std::make_pair({key2,value2})};
4.拷贝构造函数
map<T1,T2,std::less<T1>> m1;
map<T1,T2,std::less<T1>> m(m1);//T1与T2以及比较函数必须一致
5.借助已有map容器指定的区间来定义及初始化
map<T1,T2,std::less<T1>> m1({key1,value1},{key2,value2});
map<T1,T2,std::less<T1>> m2(++m1.begin(),m1.end());//包括了{key2,value2}的一个map容器
6.修改map容器的排序规则
  1.调用默认的greater进行降序
  map<T1,T2,std::greater<T1>> m;
  2.自定义
      
//一个空map
map<int, int,less<int>> m;
//初始化成员列表
map<int, int> m4{ {1,10},{2,20} };
//make_pair
map<int, int> m5{ std::make_pair(1, 10) };
//拷贝构造函数
map<int, int, greater<int>> m2(m);//error 比较函数不一致
map<int, int, less<int>> m3(m);//accept!
//map容器区间
map<int, int> m6(++m4.begin(), m4.end());
//修改map容器的排序规则
map<int, int, std::greater<int>> m7;

成员函数

find(key)	在容器中查找键值为key的键值对，如果成功找到，则返回指向该键值对的双向迭代器；反之，则返回和 end() 方法一样的迭代器。另外，如果 map 容器用 const 限定，则该方法返回的是 const 类型的双向迭代器。
lower_bound(key)	返回一个指向当前 map 容器中第一个大于或等于 key 的键值对的双向迭代器。如果 map 容器用 const 限定，则该方法返回的是 const 类型的双向迭代器
upper_bound(key)	返回一个指向当前 map 容器中第一个大于 key 的键值对的迭代器。如果 map 容器用 const 限定，则该方法返回的是 const 类型的双向迭代器
equal_range(key)	该方法返回一个 pair 对象（包含 2 个双向迭代器），其中 pair.first 和 lower_bound() 方法的返回值等价，pair.second 和 upper_bound() 方法的返回值等价。也就是说，该方法将返回一个范围，该范围中包含的键为 key 的键值对（map 容器键值对唯一，因此该范围最多包含一个键值对）
empty()	若容器为空，则返回 true；否则返回 false
size()	返回当前 map 容器中存有键值对的个数
max_size()	返回 map 容器所能容纳键值对的最大个数，其返回值与操作系统相关
operator[]	[] 运算符的重载，map[i]相当于获取对应map容器中key为i的键值对的value，另外当map容器中不包含键值为key的键值对的时候，使用[]运算符会直接往里面添加键值为key的键值对
at(key)	找到 map 容器中 key 键对应的值，如果找不到，该函数会引发 std::out_of_range 异常这是at函数与[]最大的不同
insert()	向 map 容器中插入键值对
erase()	删除 map 容器指定位置、指定键（key）值或者指定区域内的键值对
swap()	在 2 个map容器的类型一致的条件下，交换 2 个 map 容器中存储的键值对
clear()	清空 map 容器中所有的键值对
emplace()	在当前 map 容器中的指定位置处构造新键值对。其效果和插入键值对一样，但效率更高
emplace_hint()	在本质上和 emplace() 在 map 容器中构造新键值对的方式是一样的，不同之处在于，使用者必须为该方法提供一个指示键值对生成位置的迭代器，并作为该方法的第一个参数
count(key)	在当前 map 容器中，查找键为 key 的键值对的个数并返回。此外，由于 map 容器中各键值对的键的值是唯一的，因此该函数的返回值最大为 1

部分函数存在多个重载：

1.insert
pair<iterator,bool> insert (const T& val);//引用形式传递
pair<iterator,bool> insert (T&& val);//右值引用
以上两个方法都是在容器中任意位置插入一个键值对，会返回一个pair对象，这个对象包括一个迭代器，和一个判断是否成功插入的bool变量，如果插入成功为true，迭代器指向插入的位置，否则为false，迭代器指向容器中具有相同键的键值对
iterator insert (const iterator pos, const T& val);
iterator insert (const iterator pos, T&& val);
以上两个方法返回的不是pair而是迭代器，这两个insert方法会在指定的位置插入val，插入成功则返回插入的位置，失败则返回容器中具有相同键的键值对，需要注意的是就算指定了位置，最后键值对在容器中的位置仍然是按照键值排序的位置
void insert (iterator begin, iterator end);
向一个map容器中插入[begin，end)迭代器范围内的键值对
void insert ({val1, val2, ...});
一次性插入多个键值对
2.emplace
pair<iterator,bool> emplace (first,second);
iterator emplace_hint (const iterator pos,first,second);    
这两个方法使用的时候十分类似insert，除了在传递参数的时候不需要以{}括住pair对象的属性，并且效率比insert更高，因为其底层实现是在容器内部直接构造，而insert是先构造然后拷贝或移动
           
对于insert：
//1 2个
map<string, string> m;
pair<string, string> Baidu("baidu","www.baidu.com");
pair<map<string,string>::iterator,bool> p1 = m.insert(Baidu);//直接引用
cout << p1.first->first << ' ' << p1.first->second << ' ' << p1.second << endl;//baidu www.baidu.com 1
pair<map<string, string>::iterator, bool> p2 = m.insert({ "firefox","www.firefox.com" });//右值引用
cout << p2.first->first << ' ' << p2.first->second << ' ' << p2.second << endl;//firefox www.firefox.com 1
pair<map<string, string>::iterator, bool> p3 = m.insert({ "baidu","www.hao123.com" });//插入失败
cout << p3.first->first << ' ' << p3.first->second << ' ' << p3.second << endl;//baidu www.baidu.com 0
//3 4个
map<string, string> m2;
pair<string, string> p4("firefox", "www.firefox.com");
map<string, string>::iterator it = m2.begin();
auto temp1 = m2.insert(it, p4);
cout << temp1->first << ' ' << temp1->second << endl;//firefox www.firefox.com
auto temp2 = m2.insert(it, make_pair("baidu", "www.baidu.com"));
cout << temp2->first << ' ' << temp2->second << endl;//baidu www.baidu.com
for (auto c : m2) {//需要注意，就算指定了插入位置，最后map容器还是会根据键来排序
	cout << c.first << ' ' << c.second << endl;
}
//因此输出为
//baidu www.baidu.com
//firefox www.firefox.com
//5
map<string, string> m3;
m3.insert(++m2.begin(), m2.end());
for (auto c : m3) {
	cout << c.first << ' ' << c.second << endl;
}
//firefox www.firefox.com
//6
map<string, string> m4;
m4.insert({ { "baidu","www.baidu.com" }, { "firefox","www.firefox.com" } });

set

set 容器存储的各个元素，要求键 key 和值 value 必须相等。

需要注意的是，不建议直接修改set容器的值，因为对于一个set容器来说，其内部的元素的key与value是相等的，直接修改可能会破坏其排序顺序，因此最好是先删除再添加。

set 容器定义于<set>头文件，并位于 std 命名空间中

#include <set>
using namespace std;

定义

一个set容器的定义如下：

template < class T,                        // 键 key 和值 value 的类型
           class Compare = less<T>,        // 指定 set 容器内部的排序规则
           class Alloc = allocator<T>      // 指定分配器对象的类型
           > class set;

多数情况下我们只要指定第一个，有时候根据需要还可以指定set容器的比较方法。

创建以及初始化set容器：

*下列初始化都会给出默认排序，实际中可以不写，默认调用std::less<T>，可以根据需要编写自定义的比较
1.直接创建一个空的set
set<T,std::less<T>> s;
2.初始化成员列表
set<T,std::less<T>> s{value1,value2...};
3.拷贝构造函数
set<T,std::less<T>> s1;
set<T,std::less<T>> s(s1);//T与比较函数必须一致
4.借助已有set容器指定的区间来定义及初始化
set<T,std::less<T>> s1(value1,value2);
set<T,std::less<T>> s2(++s1.begin(),s1.end());//包括了{value2}的一个set容器
5.修改set容器的排序规则
  1.调用默认的greater进行降序
  set<T,std::greater<T>> s;
  2.自定义
      
//一个空set
set<int,less<int>> s;
//初始化成员列表
set<int> s4{ 10,20 };
//拷贝构造函数
set<int, greater<int>> s2(s);//error 比较函数不一致
set<int, less<int>> s3(s);//accept!
//set容器区间
set<int> s6(++s4.begin(), s4.end());
//修改set容器的排序规则
set<int, std::greater<int>> s7;

成员函数

find(val)	在容器中查找值为val的元素，如果成功找到，则返回指向该元素的双向迭代器；反之，则返回和 end() 方法一样的迭代器。另外，如果 set 容器用 const 限定，则该方法返回的是 const 类型的双向迭代器。
lower_bound(val)	返回一个指向当前 set 容器中第一个大于或等于 val 的双向迭代器。如果 set 容器用 const 限定，则该方法返回的是 const 类型的双向迭代器
upper_bound(val)	返回一个指向当前 set 容器中第一个大于 val 的元素的迭代器。如果 set 容器用 const 限定，则该方法返回的是 const 类型的双向迭代器
equal_range(val)	该方法返回一个 pair 对象（包含 2 个双向迭代器），其中 pair.first 和 lower_bound() 方法的返回值等价，pair.second 和 upper_bound() 方法的返回值等价。也就是说，该方法将返回一个范围，该范围中包含的值为 val 的元素（set 容器中各个元素是唯一的，因此该范围最多包含一个元素）
empty()	若容器为空，则返回 true；否则返回 false
size()	返回当前 set 容器中存有键值对的个数
max_size()	返回 set 容器所能容纳键值对的最大个数，其返回值与操作系统相关
insert()	向 set 容器中插入元素
erase()	删除 set 容器中存储的元素
swap()	在 2 个set容器的类型一致的条件下，交换 2 个 set 容器中存储的键值对
clear()	清空 set 容器中所有的键值对
emplace()	在当前 set 容器中的指定位置处构造新元素。其效果和插入元素一样，但效率更高
emplace_hint()	在本质上和 emplace() 在 set 容器中构造新元素的方式是一样的，不同之处在于，使用者必须为该方法提供一个指示元素生成位置的迭代器，并作为该方法的第一个参数
count(val)	在当前 set 容器中，查找值为 val 的元素的个数并返回,此外，由于 set 容器中各元素的值是唯一的，因此该函数的返回值最大为 1

有些函数有多个重载:

1.insert
pair<iterator,bool> insert (const T& val);//引用形式传递
pair<iterator,bool> insert (T&& val);//右值引用
以上两个方法都是在容器中任意位置插入一个元素，会返回一个pair对象，这个对象包括一个迭代器，和一个判断是否成功插入的bool变量，如果插入成功为true，迭代器指向插入的位置，否则为false，迭代器指向容器中具有相同值的元素
iterator insert (const iterator pos, const T& val);
iterator insert (const iterator pos, T&& val);
以上两个方法返回的不是pair而是迭代器，这两个insert方法会在指定的位置插入val，插入成功则返回插入的位置，失败则返回容器中具有相同值的元素，需要注意的是就算指定了位置，最后元素在容器中的位置仍然是按照元素值排序的位置
void insert (iterator begin, iterator end);
向一个set容器中插入[begin，end)迭代器范围内的元素
void insert ({val1, val2, ...});
一次性插入多个元素
2.emplace
pair<iterator,bool> emplace (first,second);
iterator emplace_hint (const iterator pos,first,second);    
这两个方法使用的时候十分类似insert，除了在传递参数的时候不需要以{}括住pair对象的属性，并且效率比insert更高，因为其底层实现是在容器内部直接构造，而insert是先构造然后拷贝或移动
3.erase
size_t erase (const T& val);//删除 set 容器中值为 val 的元素，返回值为删除的元素个数
iterator  erase (const iterator pos);//删除 pos 迭代器指向的元素，返回值为一个迭代器，其指向 set 容器中删除元素之后的第一个元素
iterator  erase (const iterator begin, const iterator end);//删除 [begin,end) 区间内的所有元素，返回值为一个迭代器，其指向 set 容器中删除元素之后的第一个元素
            
类似map的insert、emplace，这里不再演示
set<int> s{ 1, 2, 3, 4, 5 };
s.erase(3);
for (auto c : s) {//1 2 4 5
	cout << c << ' ';
}
cout << endl;
set<int> s2{ 3, 5, 10, 15 ,52 };
s2.erase(++s2.begin(),s2.end());
for (auto c : s2) {//3
	cout << c << ' ';
}
cout << endl;

multimap

和 map 容器十分相似，唯一的区别在于，multimap 容器中可以同时存储多（≥2）个键相同的键值对。

定义在头文件中，使用需要

#include <map>
using namespace std;

定义

一个multimap容器的定义如下：

template < class Key,                                   // 指定键（key）的类型
           class T,                                     // 指定值（value）的类型
           class Compare = less<Key>,                   // 指定排序规则
           class Alloc = allocator<pair<const Key,T> >  // 指定分配器对象的类型
           > class multimap;

多数情况下我们只要指定前两个，即key与value，有时候根据需要还可以指定multimap容器的比较方法。

*下列初始化都会给出默认排序，实际中可以不写，默认调用std::less<T1>，可以根据需要编写自定义的比较
1.直接创建一个空的multimap
multimap<T1,T2,std::less<T1>> m;
2.初始化成员列表
multimap<T1,T2,std::less<T1>> m{{key1,value1},{key2,value2}...};
3.借助pair的移动构造函数
multimap<T1,T2,std::less<T1>> m{std::make_pair({key1,value1}),std::make_pair({key2,value2})};
4.拷贝构造函数
multimap<T1,T2,std::less<T1>> m1;
multimap<T1,T2,std::less<T1>> m(m1);//T1与T2以及比较函数必须一致
5.借助已有multimap容器指定的区间来定义及初始化
multimap<T1,T2,std::less<T1>> m1({key1,value1},{key2,value2});
multimap<T1,T2,std::less<T1>> m2(++m1.begin(),m1.end());//包括了{key2,value2}的一个multimap容器
6.修改multimap容器的排序规则
  1.调用默认的greater进行降序
  multimap<T1,T2,std::greater<T1>> m;
  2.自定义
      
//一个空multimap
multimap<int, int,less<int>> m;
//初始化成员列表
multimap<int, int> m4{ {1,10},{2,20} };
//make_pair
multimap<int, int> m5{ std::make_pair(1, 10) };
//拷贝构造函数
multimap<int, int, greater<int>> m2(m);//error 比较函数不一致
multimap<int, int, less<int>> m3(m);//accept!
//multimap容器区间
multimap<int, int> m6(++m4.begin(), m4.end());
//修改multimap容器的排序规则
multimap<int, int, std::greater<int>> m7;

成员函数

find(key)	在容器中查找键值为key的键值对，如果成功找到，则返回指向该键值对的双向迭代器；反之，则返回和 end() 方法一样的迭代器。另外，如果 multimap 容器用 const 限定，则该方法返回的是 const 类型的双向迭代器。
lower_bound(key)	返回一个指向当前 multimap 容器中第一个大于或等于 key 的键值对的双向迭代器。如果 multimap 容器用 const 限定，则该方法返回的是 const 类型的双向迭代器
upper_bound(key)	返回一个指向当前 multimap 容器中第一个大于 key 的键值对的迭代器。如果 multimap 容器用 const 限定，则该方法返回的是 const 类型的双向迭代器
equal_range(key)	该方法返回一个 pair 对象（包含 2 个双向迭代器），其中 pair.first 和 lower_bound() 方法的返回值等价，pair.second 和 upper_bound() 方法的返回值等价。也就是说，该方法将返回一个范围，该范围中包含的键为 key 的键值对
empty()	若容器为空，则返回 true；否则返回 false
size()	返回当前 multimap 容器中存有键值对的个数
max_size()	返回 multimap 容器所能容纳键值对的最大个数，其返回值与操作系统相关
insert()	向 multimap 容器中插入键值对
erase()	删除 multimap 容器指定位置、指定键（key）值或者指定区域内的键值对
swap()	在 2 个multimap容器的类型一致的条件下，交换 2 个 multimap 容器中存储的键值对
clear()	清空 multimap 容器中所有的键值对
emplace()	在当前 multimap 容器中的指定位置处构造新键值对。其效果和插入键值对一样，但效率更高
emplace_hint()	在本质上和 emplace() 在 multimap 容器中构造新键值对的方式是一样的，不同之处在于，使用者必须为该方法提供一个指示键值对生成位置的迭代器，并作为该方法的第一个参数
count(key)	在当前 multimap 容器中，查找键为 key 的键值对的个数并返回

由于multimap支持的操作map都支持，这里不再演示

mulitset

和 set 容器十分相似，唯一的区别在于，multiset 容器中可以同时存储多（≥2）个键相同的键值对。

需要注意的是，不建议直接修改 multiset 容器的值，因为对于一个 multiset 容器来说，其内部的元素的key与value是相等的，直接修改可能会破坏其排序顺序，因此最好是先删除再添加。

multiset 容器定义于<set>头文件，并位于 std 命名空间中

#include <set>
using namespace std;

定义

一个multiset容器的定义如下：

template < class T,                        // 存储元素的类型
           class Compare = less<T>,        // 指定容器内部的排序规则
           class Alloc = allocator<T> >    // 指定分配器对象的类型
           > class multiset;

多数情况下我们只要指定第一个，有时候根据需要还可以指定set容器的比较方法。

创建以及初始化multiset容器的方式与set容器一致

*下列初始化都会给出默认排序，实际中可以不写，默认调用std::less<T>，可以根据需要编写自定义的比较
1.直接创建一个空的multiset
multiset<T,std::less<T>> s;
2.初始化成员列表
multiset<T,std::less<T>> s{value1,value2...};
3.拷贝构造函数
multiset<T,std::less<T>> s1;
multiset<T,std::less<T>> s(s1);//T与比较函数必须一致
4.借助已有multiset容器指定的区间来定义及初始化
multiset<T,std::less<T>> s1(value1,value2);
multiset<T,std::less<T>> s2(++s1.begin(),s1.end());//包括了{value2}的一个multiset容器
5.修改multiset容器的排序规则
  1.调用默认的greater进行降序
  multiset<T,std::greater<T>> s;
  2.自定义

成员函数

find(val)	在容器中查找值为val的元素，如果成功找到，则返回指向该元素的双向迭代器；反之，则返回和 end() 方法一样的迭代器。另外，如果 multiset 容器用 const 限定，则该方法返回的是 const 类型的双向迭代器。
lower_bound(val)	返回一个指向当前 multiset 容器中第一个大于或等于 val 的双向迭代器。如果 multiset 容器用 const 限定，则该方法返回的是 const 类型的双向迭代器
upper_bound(val)	返回一个指向当前 multiset 容器中第一个大于 val 的元素的迭代器。如果 multiset 容器用 const 限定，则该方法返回的是 const 类型的双向迭代器
equal_range(val)	该方法返回一个 pair 对象（包含 2 个双向迭代器），其中 pair.first 和 lower_bound() 方法的返回值等价，pair.second 和 upper_bound() 方法的返回值等价。也就是说，该方法将返回一个范围，该范围中包含的值为 val 的元素（multiset 容器中各个元素是唯一的，因此该范围最多包含一个元素）
empty()	若容器为空，则返回 true；否则返回 false
size()	返回当前 multiset 容器中存有键值对的个数
max_size()	返回 multiset 容器所能容纳键值对的最大个数，其返回值与操作系统相关
insert()	向 multiset 容器中插入元素
erase()	删除 multiset 容器中存储的元素
swap()	在 2 个multiset容器的类型一致的条件下，交换 2 个 multiset 容器中存储的键值对
clear()	清空 multiset 容器中所有的键值对
emplace()	在当前 multiset 容器中的指定位置处构造新元素。其效果和插入元素一样，但效率更高
emplace_hint()	在本质上和 emplace() 在 multiset 容器中构造新元素的方式是一样的，不同之处在于，使用者必须为该方法提供一个指示元素生成位置的迭代器，并作为该方法的第一个参数
count(val)	在当前 multiset 容器中，查找值为 val 的元素的个数并返回,此外，由于 multiset 容器中各元素的值是唯一的，因此该函数的返回值最大为 1