文章目录

• • 测试环境
  • multimap介绍
  • 头文件
  • 模块类定义
  • 对象构造
  • 初始化
  • 元素访问
  • 元素插入和删除
  • 元素查找
  • 容器大小
  • 迭代器
  • 其他函数

测试环境

系统：ubuntu 22.04.2 LTS 64位
gcc版本：11.3.0
编辑器：vsCode 1.76.2

multimap介绍

1. 关联式容器。
2. 每个元素都包含用于排序的键和对应的值。
3. 键值是不要求唯一（map中键要求唯一），同一个键可以对应多个值。
4. 支持双向迭代器。
5. 在插入、删除和搜索时间复杂度为log(n)。
6. 键不可以直接修改，需要先删除，再添加；值可以直接修改

头文件

#include <map>

模块类定义

template <typename _Key, typename _Tp, typename _Compare = std::less<_Key>,
	    typename _Alloc = std::allocator<std::pair<const _Key, _Tp> > >
    class multimap{};

_Key：表示存储的键数据类型
_Tp：表示存储的值的数据类型
_Compare：表示按照键的排序方式。
_Alloc：表示所存储分配器的类型，负责元素内存的分配和释放。可选参数，一般不使用。

对象构造

/*构造一个空的map对象*/
std::multimap<int,std::string> multiMap1;
/*构造map对象，默认升序排序*/
std::multimap<int,std::string> multiMap2;
/*拷贝构造函数*/
std::multimap<int,std::string> multiMap3(multiMap1);
/*移动构造函数*/
std::multimap<int,std::string> multiMap4(std::move(multiMap3));
/*初始化列表构造函数*/
std::multimap<int,std::string> multiMap5({{1,"a"},{2,"b"},{3,"c"},{4,"d"},{5,"e"}});
/*初始化列表构造函数,并按升序排序*/
std::multimap<int,std::string,std::greater<int> > multiMap6({{1,"a"},{2,"b"},{3,"c"},{4,"d"},{5,"e"}});
/*指定迭代器范围构造函数*/
std::multimap<int,std::string> multiMap7(multiMap5.begin(), ++multiMap5.begin());
/*指定迭代器并指定排序规则*/
std::multimap<int,std::string> multiMap8(multiMap5.begin(), ++multiMap5.begin(),std::less<int>());

初始化

/*使用初始化列表初始化*/
multiMap1 = {{1,"a"}, {1,"b"}, {2,"c"}, {3,"d"},{4,"m"}};

元素访问

不支持at()函数和下标运算符“[]”获取元素

元素插入和删除

函数	返回值	功能
clear()	无	清空所有元素
erase()	迭代器或删除元素数量	清除指定位置的一个元素、通过迭代器指定范围内的元素或通过键删除值
emplace()	键值对	插入元素。插入成功时第一个元素是指向新插入元素的迭代器，失败时第一个元素是指向以存在元素的迭代器，第二个元素表示插入结果，true成功，false失败。
emplace_hint()	迭代器	插入成功返回新插入元素的迭代器，插入失败时返回已存在元素的迭代器
insert()	键值对、迭代器、无	1）在指定位置插入1个元素。2）复制通过迭代器指定范围的元素。3）通过初始化列表插入元素。4）直接插入元素。

/*清空容器*/
multiMap1.clear();
/*直接构造或移动语句插入元素*/
auto ret = multiMap1.emplace(1,"hello");
std::cout << "key:"<<ret->first<<" value:"<<ret->second<<std::endl;
/*直接构造或移动语句在指定位置插入元素*/
auto ret1 = multiMap1.emplace_hint(multiMap1.begin(),1,"word");
std::cout << "key:"<<ret1->first<<" value:"<<ret1->second<<std::endl;
/*插入元素，返回键值对*/
multiMap1.insert({1,"ni hao!"});
multiMap1.insert(std::make_pair<int,std::string>(4,"four"));
/*插入元素，返回迭代器*/
multiMap1.insert(multiMap1.begin(),{0,"zero"});
multiMap1.insert(multiMap1.begin(),std::make_pair<int,std::string>(1,"first"));
/*初始化列表插入,无返回值*/
multiMap1.insert({{2,"two"},{3,"three"},{4,"four"}});
/*使用迭代器指定范围插入元素，无返回值*/
std::multimap<int,std::string> multiMap9{{5,"five"},{6,"six"}};
multiMap1.insert(multiMap9.begin(),multiMap9.end());
/*删除单个元素*/
auto ret2 = multiMap1.erase(multiMap1.begin());
std::cout << "ret2.first:"<<ret2->first<<" ret2.second:"<<ret2->second<<std::endl;
for (auto & item : multiMap1)
{
    std::cout<<"key:"<<item.first<<" value:"<<item.second<<std::endl;
}
/*删除指定范围的元素*/
auto ret3 = multiMap1.erase(multiMap1.begin(), ++multiMap1.begin());
std::cout << "ret3.first:"<<ret3->first<<" ret3.second:"<<ret3->second<<std::endl;
for (auto & item : multiMap1)
{
    std::cout<<"key:"<<item.first<<" value:"<<item.second<<std::endl;
}
/*根据键值删除元素*/
int iCount = multiMap1.erase(1);
std::cout << "iCount："<<iCount<<std::endl;

元素查找

函数	返回值	功能
count()	std::size_t	返回给定键对应元素的数量
find()	迭代器	查找指定键对应的第一个元素的位置,未找到则返回end()
lower_bound()	迭代器	查找第一个大于或等于给定键的第一个元素的位置,未找到则返回end()
upper_bound()	迭代器	查找第一个大于给定键的第一个元素元素的位置，未找到返回end()
equal_range()	迭代器	获取给定键的lower_bound和upper_bound

multiMapTest = {{1,10},{1,11},{4,12},{1,13},{5,14},{8,15},{7,16},{8,17},{9,18},{9,19}};  
/*判断容器中指定键对应的元素数量*/
std::cout << multiMapTest.count(1)<<std::endl;
/*查找指定键的元素所在的位置*/
int iCount = multiMapTest.count(1);
std::multimap<int,int>::iterator itrRet4 = multiMapTest.find(1);
std::cout << "find():"<<std::endl;
while(iCount--)
{
    std::cout << "key:"<<itrRet4->first<<" value:"<<itrRet4->second<<std::endl;
    itrRet4++;
}
/*查找第一个大于等于给定键的第一个元素的位置*/
std::multimap<int,int>::iterator itrRet5 = multiMapTest.lower_bound(1);
std::cout << "key:"<<itrRet5->first<<" value:"<<itrRet5->second<<std::endl;
/*查找第一个大于给定键的元素的位置*/
std::multimap<int,int>::iterator itrRet6 = multiMapTest.upper_bound(3);
std::cout << "key:"<<itrRet6->first<<" value:"<<itrRet6->second<<std::endl;
/*分别返回lower_bound和upper_bound*/
auto ret7 = multiMapTest.equal_range(1);
std::cout << "lower_bound key:"<<ret7.first->first<<" lower_bound value:"<<ret7.first->second<<std::endl;
std::cout << "upper_bound key:"<<ret7.second->first<<" upper_bound value:"<<ret7.second->second<<std::endl;

容器大小

函数	返回值	功能
size()	std::size_t	获取当前容器中的元素数量
empty()	bool	判断当前容器是否为空，为空返回true，否则返回false
max_size()	std::size_t	返回容器的最大容量

multiMapTest = {{1,10},{1,11},{4,12},{4,13},{5,14},{8,15},{7,16},{8,17},{9,18},{9,19}};
/*判断元素的数量*/
std::cout<<multiMapTest.size()<<std::endl;
/*判断容器最大能容纳的元素的数量*/
std::cout<<multiMapTest.max_size()<<std::endl;
/*判断容器是否为空*/
std::cout<<std::boolalpha<<multiMapTest.empty()<<std::endl;

迭代器

类型	功能
iterator	正向访问迭代器。从前向后访问元素，可以读取也可以修改
const_iterator	常量正向访问迭代器。从前向后访问元素，只能读取不能修改
reverse_iterator	逆向访问迭代器。从后向前访问元素，可以读取也可以修改
const_reverse_iterator	常量逆向访问迭代器。从后向前访问元素，只能读取不能修改

函数	返回值	功能
begin()	正向访问迭代器	返回指向multimap对象首元素所在位置的迭代器
end()	正向访问迭代器	返回指向multimap对象末尾元素的下一个位置的迭代器
cbegin()	常量正向访问迭代器	返回指向multimap对象首元素所在位置的常量迭代器
cend()	常量正向访问迭代器	返回指向multimap对象末尾元素的下一个位置的迭代器
rbegin()	逆向访问迭代器	返回指向multimap对象末尾元素位置的迭代器
rend()	逆向访问迭代器	返回指向multimap对象首元素的前一个位置的迭代器
crbegin()	常量逆向访问迭代器	返回指向multimap对象末尾元素位置的常量迭代器
crend()	常量逆向访问迭代器	返回指向multimap对象首元素的前一个位置的常量迭代器

std::multimap<int,int>multiMapTest({{1,11},{1,11},{3,12},{3,13},{9,14},{6,15},{7,16},{6,17},{9,18},{10,19}});
/*正向随机访问迭代器，每个元素+10，并打印输出（1--21 1--21 3--22 3--23 6--25 6--27 7--26 9--24 9--28 10--29）*/
std::multimap<int,int>::iterator itr;
for (itr = multiMapTest.begin(); itr != multiMapTest.end(); itr++)
{
    /* 修改元素值每个元素+10 */
    itr->second += 10; 
    /* 访问元素 */
    std::cout <<"first:"<<itr->first<< " second:"<<itr->second<<std::endl;
}
std::cout<<std::endl;
/*常量正向随机访问迭代器，并打印输出（1--21 1--21 3--22 3--23 6--25 6--27 7--26 9--24 9--28 10--29）*/
std::multimap<int,int>::const_iterator cItr;
for (cItr = multiMapTest.cbegin(); cItr != multiMapTest.cend(); cItr++)
{
    /* 不允许修改值，编译报错 */
    //*cItr += 10; 
    /* 访问元素 */
    std::cout <<"first:"<<cItr->first<< " second:"<<cItr->second<<std::endl;
}
std::cout<<std::endl;
/*逆向随机访问迭代器，每个元素+100，并打印输出（10--129 9--128 9 --124 7--126 6--127 6--125 3--123 3--122 1--121 1--121）*/
std::multimap<int,int>::reverse_iterator rItr;
for (rItr= multiMapTest.rbegin(); rItr!= multiMapTest.rend(); rItr++)
{
    /* 修改元素值 */
    rItr->second += 100; 
    /* 访问元素 */
    std::cout <<"first:"<<rItr->first<< " second:"<<rItr->second<<std::endl;
}
std::cout<<std::endl;
/*常量逆向随机访问迭代器，并打印输出（10--129 9--128 9 --124 7--126 6--127 6--125 3--123 3--122 1--121 1--121）*/
std::multimap<int,int>::const_reverse_iterator crItr;
for (crItr= multiMapTest.crbegin(); crItr!= multiMapTest.crend(); crItr++)
{
    /* 不允许修改元素值， 编译报错 */
    //*crItr += 100; 
    /* 访问元素 */
    std::cout <<"first:"<<crItr->first<< " second:"<<crItr->second<<std::endl;
}
std::cout << std::endl;

其他函数

函数名	返回值	功能
swap()	无	交换两个容器的元素

/*交互两个容器元素的值,无返回值*/
std::multimap<int,int> multimapSwap1 = {{1,5},{2,4},{3,3},{3,2},{5,1}};
std::multimap<int,int> multimapSwap2 = {{6,1},{6,2},{8,3},{8,6},{9,8}};
/*方式1， multimapSwap1={{6,1},{6,2},{8,3},{8,6},{9,8}}, multimapSwap2={{1,5},{2,4},{3,3},{3,2},{5,1}}*/
multimapSwap1.swap(multimapSwap2);
std::cout << "multimapSwap1:"<<std::endl;
for (auto &item : multimapSwap1)
{
    std::cout<<"key:"<<item.first<<" value:"<<item.second<<std::endl;
}

std::cout << "multimapSwap2:"<<std::endl;
for (auto &item : multimapSwap2)
{
    std::cout<<"key:"<<item.first<<" value:"<<item.second<<std::endl;
}
/*mapSwap1={{1,5},{2,4},{3,3},{3,2},{5,1}}, multimapSwap2={{6,1},{6,2},{8,3},{8,6},{9,8}}*/
std::swap(multimapSwap1,multimapSwap2);
std::cout << "multimapSwap1:"<<std::endl;
for (auto &item : multimapSwap1)
{
    std::cout<<"key:"<<item.first<<" value:"<<item.second<<std::endl;
}

std::cout << "multimapSwap2:"<<std::endl;
for (auto &item : multimapSwap2)
{
    std::cout<<"key:"<<item.first<<" value:"<<item.second<<std::endl;
}