STL容器之＜map＞

测试环境

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

map介绍

1. 关联式容器。
2. 每个元素都包含用于排序的键和对应的值。
3. 键值是唯一的。
4. 支持双向迭代器。
5. 在插入、删除和搜索时间复杂度为log(n)。

头文件

#include 

模块类定义

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

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

对象构造

/*构造一个空的map对象*/
std::map<int,int> map1;
/*构造map对象，默认降序排序*/
std::map<int,int,std::greater<int> > map2;
/*拷贝构造函数*/
std::map<int,int> map3(map1);
/*移动构造函数*/
std::map<int,int> map4(std::move(map1));
/*初始化列表构造函数*/
std::map<int,int> map5({{1,1},{2,2},{3,3},{4,4},{5,5}});
/*初始化列表构造函数,并按降序排序*/
std::map<int,int> map7({{1,1},{2,2},{3,3},{4,4},{5,5}}, std::less<int>());
/*指定迭代器范围构造函数*/
std::map<int,int> map8(map5.begin(), ++map5.begin());
/*指定迭代器并指定排序规则*/
std::map<int,int> map9(map5.begin(), ++map5.begin(), std::less<int>());

初始化

/*初始化列表初始化*/
map1 = {{1,10},{2,11},{3,12},{4,13},{5,14},{6,15},{7,16},{8,17},{9,18},{10,19}};

元素访问

函数名	返回值	功能
at()	键对应的值	通过键访问值
[]	键对应的值	通过键访问值

/*使用at函数通过键访问值*/
map1 = {{1,10},{2,11},{3,12},{4,13},{5,14},{6,15},{7,16},{8,17},{9,18},{10,19}};
for (int i = 1; i <= 10; i++)
{
    std::cout<<"key:"<<i<<" value:"<<map1.at(i)<<std::endl;
}
/*使用[]通过键访问值*/
for (int i = 1; i <= 10; i++)
{
    std::cout<<"key:"<<i<<" value:"<<map1[i]<<std::endl;
}

元素插入和删除

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

/*直接构造并插入元素*/
auto ret = map1.emplace(0,1);
std::cout << "ret.first.first:"<<ret.first->first<<" ret.first.second:"<<ret.first->second<<std::endl;
std::cout << "ret.second:"<<std::boolalpha<<ret.second<<std::endl;
/*直接构造并插入元素*/
auto result = map1.emplace(std::make_pair<int,int>(11,20));
std::cout << "result.first.first:"<<result.first->first<<" result.first.second:"<<result.first->second<<std::endl;
std::cout << "result.second:"<<std::boolalpha<<result.second<<std::endl;
/*直接构造并在指定位置插入元素*/
auto ret1 = map1.emplace_hint(map1.begin(),1,66);
std::cout << "ret1.first:"<<ret1->first<<" ret1.second:"<<ret1->second<<std::endl;
/*删除单个元素*/
auto ret2 = map1.erase(map1.begin());
/*删除指定范围的元素*/
auto ret3 = map1.erase(map1.begin(), ++map1.begin());
/*根据键值删除元素*/
int iCount = map1.erase(6);
std::cout << "iCount："<<iCount<<std::endl;
/*清空map中的元素*/
map1.clear();
/*插入元素，返回键值对*/
map1.insert({1,0});
map1.insert(std::make_pair<int,int>(88,0));
/*插入元素，返回迭代器*/
map1.insert(map1.begin(),{0,0});
map1.insert(map1.begin(),std::make_pair<int,int>(1,1));
/*初始化列表插入,无返回值*/
map1.insert({{2,2},{3,3},{4,4}});
/*使用迭代器指定范围插入元素，无返回值*/
std::map<int,int> map10{{5,5},{6,6}};
map1.insert(map10.begin(),map10.end());

元素查找

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

/*判断容器中指定键对应的元素数量*/
std::cout << map1.count(2)<<std::endl;
/*查找指定键的元素所在的位置*/
auto ret4 = map1.find(3);
std::cout<<"first: "<<ret4->first<<" second:"<<ret4->second<<std::endl;
/*查找第一个大于等于给定键的元素的位置*/
auto ret5 = map1.lower_bound(3);
std::cout << "key:"<<ret5->first<<" value:"<<ret5->second<<std::endl;
/*查找第一个大于给定键的元素的位置*/
auto ret6 = map1.upper_bound(2);
std::cout << "key:"<<ret6->first<<" value:"<<ret6->second<<std::endl;
/*分别返回lower_bound和upper_bound*/
auto ret7 = map1.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	返回容器的最大容量

/*判断元素的数量*/
std::cout<<map1.size()<<std::endl;
/*判断容器最大能容纳的元素的数量*/
std::cout<<map1.max_size()<<std::endl;
/*判断容器是否为空*/
std::cout<<map1.empty()<<std::endl;/*判断队列中元素数量*/

迭代器

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

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

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

/*常量逆向随机访问迭代器，并打印输出（129 128 127 126 125 124 123 122 121 120）*/
std::map<int,int>::const_reverse_iterator crItr;
for (crItr= mapTest.crbegin(); crItr!= mapTest.crend(); crItr++)
{
    /* 不允许修改元素值， 编译报错 */
    //*crItr += 100; 
    /* 访问元素 */
    std::cout <<"first:"<<crItr->first<< " second:"<<crItr->second<<std::endl;
}
std::cout << std::endl;

其他函数

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

/*交互两个容器元素的值,无返回值*/
std::map<int,int> mapSwap1 = {{1,6},{2,6},{3,6},{4,6},{5,6}};
std::map<int,int> mapSwap2 = {{1,8},{2,8},{3,8},{4,8},{5,8}};
/*方式1， mapSwap1={{1,8},{2,8},{3,8},{4,8},{5,8}}, mapSwap2={{1,6},{2,6},{3,6},{4,6},{5,6}}*/
mapSwap1.swap(mapSwap2);
/*mapSwap1={{1,6},{2,6},{3,6},{4,6},{5,6}}, mapSwap2={{1,8},{2,8},{3,8},{4,8},{5,8}}*/
std::swap(mapSwap1,mapSwap2);