目录
本质区别在于std::map底层使用红黑树,而std::unordered_map使用的是hash map。
1、std::map
头文件:<map>
类声明:
template<
class Key,
class T,
class Compare = std::less<Key>,
class Allocator = std::allocator<std::pair<const Key, T> >
> class map;
namespace pmr { //c++17起
template <class Key, class T, class Compare = std::less<Key>>
using map = std::map<Key, T, Compare,
std::pmr::polymorphic_allocator<std::pair<const Key,T>>>
}
std::map 是有序键值对容器,它的元素的键是唯一的。用比较函数 Compare 排序键。搜索、移除和插入操作拥有对数复杂度。 map 通常实现为红黑树。
在每个标准库使用比较 (Compare) 概念的位置,以等价关系检验唯一性。不精确而言,若二个对象 a 与 b 互相比较不小于对方 : !comp(a, b) && !comp(b, a) ,则认为它们等价(非唯一)。
std::map 满足容器 (Container) 、知分配器容器 (AllocatorAwareContainer) 、关联容器 (AssociativeContainer) 和可逆容器 (ReversibleContainer) 的要求。
成员函数
(构造函数) | 构造 map (公开成员函数) |
(析构函数) |
析构 map (公开成员函数) |
operator= |
赋值给容器 (公开成员函数) |
get_allocator |
返回相关的分配器 (公开成员函数) |
元素访问 |
|
at (C++11) |
访问指定的元素,同时进行越界检查 (公开成员函数) |
operator[] |
访问或插入指定的元素 (公开成员函数) |
迭代器 |
|
begincbegin (C++11) |
返回指向起始的迭代器 (公开成员函数) |
endcend (C++11) |
返回指向末尾的迭代器 (公开成员函数) |
rbegincrebegin (C++11) |
返回指向起始的逆向迭代器 (公开成员函数) |
rendcrend (C++11) |
返回指向末尾的逆向迭代器 (公开成员函数) |
容量 |
|
empty |
检查容器是否为空 (公开成员函数) |
size |
返回容纳的元素数 (公开成员函数) |
max_size |
返回可容纳的最大元素数 (公开成员函数) |
修改器 |
|
clear |
清除内容 (公开成员函数) |
insert |
插入元素或结点 (C++17 起) (公开成员函数) |
insert_or_assign (C++17) |
插入元素,或若键已存在则赋值给当前元素 (公开成员函数) |
emplace (C++11) |
原位构造元素 (公开成员函数) |
emplace_hint (C++11) |
使用提示原位构造元素 (公开成员函数) |
try_emplace (C++17) |
若键不存在则原位插入,若键存在则不做任何事 (公开成员函数) |
erase |
擦除元素 (公开成员函数) |
swap |
交换内容 (公开成员函数) |
extract (C++17) |
从另一容器释出结点 (公开成员函数) |
merge (C++17) |
从另一容器接合结点 (公开成员函数) |
查找 |
|
count |
返回匹配特定键的元素数量 (公开成员函数) |
find |
寻找带有特定键的元素 (公开成员函数) |
contains (C++20) |
检查容器是否含有带特定键的元素 (公开成员函数) |
equal_range |
返回匹配特定键的元素范围 (公开成员函数) |
lower_bound |
返回指向首个不小于给定键的元素的迭代器 (公开成员函数) |
upper_bound |
返回指向首个大于给定键的元素的迭代器 (公开成员函数) |
观察器 |
|
key_comp |
返回用于比较键的函数 (公开成员函数) |
value_comp |
返回用于在value_type类型的对象中比较键的函数。 (公开成员函数) |
2、std::unordered_map
头文件: <unordered_map>
类声明
template<
class Key,
class T,
class Compare = std::less<Key>,
class Allocator = std::allocator<std::pair<const Key, T> >
> class map;
namespace pmr { //c++17起
template <class Key,
class T,
class Hash = std::hash<Key>,
class KeyEqual = std::equal_to<Key>>
using unordered_map = std::unordered_map<Key, T, Hash, Pred,
std::pmr::polymorphic_allocator<std::pair<const Key,T>>>;
}
unordered_map 是关联容器,含有带唯一键的键-值 pair 。搜索、插入和元素移除拥有平均常数时间复杂度。
元素在内部不以任何特定顺序排序,而是组织进桶中。元素放进哪个桶完全依赖于其键的哈希。这允许对单独元素的快速访问,因为一旦计算哈希,则它准确指代元素所放进的桶。
std::unordered_map 满足容器 (Container) 、知分配器容器 (AllocatorAwareContainer) 、无序关联容器 (UnorderedAssociativeContainer) 的要求。
成员函数
(构造函数) |
构造 unordered_map (公开成员函数) |
(析构函数) |
析构 unordered_map (公开成员函数) |
operator= |
赋值给容器 (公开成员函数) |
get_allocator |
返回相关的分配器 (公开成员函数) |
迭代器 |
|
begincbegin |
返回指向起始的迭代器 (公开成员函数) |
endcend |
返回指向末尾的迭代器 (公开成员函数) |
容量 |
|
empty |
检查容器是否为空 (公开成员函数) |
size |
返回容纳的元素数 (公开成员函数) |
max_size |
返回可容纳的最大元素数 (公开成员函数) |
修改器 |
|
clear |
清除内容 (公开成员函数) |
insert |
插入元素或结点 (C++17 起) (公开成员函数) |
insert_or_assign (C++17) |
插入元素,或若键已存在则赋值给当前元素 (公开成员函数) |
emplace |
原位构造元素 (公开成员函数) |
emplace_hint |
使用提示原位构造元素 (公开成员函数) |
try_emplace (C++17) |
若键不存在则原位插入,若键存在则不做任何事 (公开成员函数) |
erase |
擦除元素 (公开成员函数) |
swap |
交换内容 (公开成员函数) |
extract (C++17) |
从另一容器释出结点 (公开成员函数) |
merge (C++17) |
从另一容器接合结点 (公开成员函数) |
查找 |
|
at |
访问指定的元素,同时进行越界检查 (公开成员函数) |
operator[] |
访问或插入指定的元素 (公开成员函数) |
count |
返回匹配特定键的元素数量 (公开成员函数) |
find |
寻找带有特定键的元素 (公开成员函数) |
contains (C++20) |
检查容器是否含有带特定键的元素 (公开成员函数) |
equal_range |
返回匹配特定键的元素范围 (公开成员函数) |
桶接口 |
|
begin(size_type) cbegin(size_type) |
返回一个迭代器,指向指定的桶的开始 (公开成员函数) |
end(size_type) cend(size_type) |
返回一个迭代器,指向指定的桶的末尾 (公开成员函数) |
bucket_count |
返回桶数 (公开成员函数) |
max_bucket_count |
返回桶的最大数量 (公开成员函数) |
bucket_size |
返回在特定的桶中的元素数量 (公开成员函数) |
bucket |
返回带有特定键的桶 (公开成员函数) |
哈希策略 |
|
load_factor |
返回每个桶的平均元素数量 (公开成员函数) |
max_load_factor | 管理每个桶的平均元素数量的最大值 (公开成员函数) |
rehash |
至少为指定数量的桶预留存储空间。 这会重新生成哈希表。 (公开成员函数) |
reserve |
为至少为指定数量的元素预留存储空间。 这会重新生成哈希表。 (公开成员函数) |
观察器 |
|
hash_function |
返回用于对关键哈希的函数 (公开成员函数) |
key_eql |
返回用于比较键的相等性的函数 (公开成员函数) |
/*================================================================
* Copyright (C) 2021 baichao All rights reserved.
*
* 文件名称:unordered_map.cpp
* 创 建 者:baichao
* 创建日期:2021年01月13日
* 描 述:
*
================================================================*/
#include <iostream>
#include <string>
#include <unordered_map>
int main()
{
// 创建三个 string 的 unordered_map (映射到 string )
std::unordered_map<std::string, std::string> u = {
{"RED","#FF0000"},
{"GREEN","#00FF00"},
{"BLUE","#0000FF"}
};
// 迭代并打印 unordered_map 的关键和值
for( const auto& n : u ) {
std::cout << "Key:[" << n.first << "] Value:[" << n.second << "]\n";
}
// 添加新入口到 unordered_map
u["BLACK"] = "#000000";
u["WHITE"] = "#FFFFFF";
// 用关键输出值
std::cout << "The HEX of color RED is:[" << u["RED"] << "]\n";
std::cout << "The HEX of color BLACK is:[" << u["BLACK"] << "]\n";
//返回哈希函数
std::hash<std::string> hashFunc = u.hash_function(); //因为unordered_map实例u中的key是std::string类型,所以函数返回值也就是std::hash<std:;string>
float loadFactor = u.load_factor();
float maxLoadFactor = u.max_load_factor();
return 0;
}
根据结果可以看到std::unoreded_map的负载因子是1,std::map没有负载因子,负载因子指哈希表中元素和数组大小的比值,std::unoreded_map设置为1,我的理解是为了充分利用内存,但是冲突会比较大。这也是博主稍微有点想不通的原因,难道std::unoreded_map的设计者喜欢反其道而行之,用时间换空间,这个骚操作我也是有点懵逼。
顺带多一嘴,redis的负载因子也是1,redis极端情况下可能是5,就是持久化的时候,需要fork操作,这个时候不会分配内存,所以redis源码中有判断如果大于数组长度的5倍则马上扩容(redis6.0是如此,其余的不敢保证)