c++11 unordered_map自定义key

已于 2022-09-26 15:20:33 修改
阅读量3k 收藏 28
点赞数 13
分类专栏： modern C++ 文章标签： c++ 哈希算法 散列表
于 2022-09-16 21:29:38 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/weixin_45030965/article/details/126880141
版权

文章目录

一、unordered_map简介

unordered_map 是用哈希函数组织的map，采用哈希表存储数据，元素的位置取决于计算的散列值，是关联容器的一种。unordered_map使用一个哈希函数和关键字类型的==运算符（==运算符用来当发生碰撞时比较关键字key）来组织元素。

unordered_map的元素是关键字 - 值（key-value）对，无序保存元素，查询效率较高。在无序容器中，元素没有明确的排列次序，我们只关心的是，某个特定元素是否位于容器内。

元素值或其insert顺序，都不影响元素的位置，而且元素的位置有可能在容器生命中被改变。比如你放n个元素到这种集合内，它们的次序不明确，并且可能随时间而改变。

哈希表是一种以空间换时间的一种思想。

哈希函数又叫散列函数，哈希表又叫散列表。

二、自定义key

默认情况下，unordered_map使用关键字类型的 == 运算符来比较元素，因此默认情况下我们可以直接定义关键字是内置类型，比如string ，int ，指针等，标准库为这些内置类型提供了一个hash模板，hash<key_type>来组织其元素。

但是不能直接自定义关键字类型，比如结构体，因为我们不能使用标准库提供的默认hash模板，我们必须自己提供hash模板。

unordered_map是一个模板类，有5个参数：

  /**
   *  @brief A standard container composed of unique keys (containing
   *  at most one of each key value) that associates values of another type
   *  with the keys.
   *
   *  @ingroup unordered_associative_containers
   *
   *  @tparam  _Key    Type of key objects.
   *  @tparam  _Tp     Type of mapped objects.
   *  @tparam  _Hash   Hashing function object type, defaults to hash<_Value>.
   *  @tparam  _Pred   Predicate function object type, defaults
   *                   to equal_to<_Value>.
   *  @tparam  _Alloc  Allocator type, defaults to 
   *                   std::allocator<std::pair<const _Key, _Tp>>.
   *
   *
   * The resulting value type of the container is std::pair<const _Key, _Tp>.
   *
   *  Base is _Hashtable, dispatched at compile time via template
   *  alias __umap_hashtable.
   */

template<typename _Key, typename _Tp,
	   typename _Hash = hash<_Key>,
	   typename _Pred = equal_to<_Key>,
	   typename _Alloc = allocator<std::pair<const _Key, _Tp>>>
    class unordered_map
    {
		......
	}

unordered_map模板类的第一参数就是key，对 key 的要求反而比map的要求更严格。它要求 key 具备两个条件，一是可以计算 hash 值，二是能够执行相等比较操作。第一个是因为散列表的要求，只有计算 hash 值才能放入散列表，第二个则是因为 hash 值可能会冲突，所以当 hash 值相同时，就要比较真正的 key 值

因此我们要自定义key，主要修改是第三个参数和第四个参数。
第三个参数是：哈希函数对象类型，用来确定key在哈希表中的位置，默认是hash<_Key>模板。
可以使用类模板特例化hash<_Key>模板，或者用函数重载调用operator()。

第四个参数是：发生碰撞时用来比较key值，因为我们自定义key值，所以我们要重载 key 类型 == 运算符。
默认的 std::equal_to 会去调用 key 类型的 operator() 函数，比较内置类型的key值。

typename _Pred = equal_to<_Key>,

// One of the @link comparison_functors comparison functors@endlink.
  template<typename _Tp>
    struct equal_to : public binary_function<_Tp, _Tp, bool>
    {
      _GLIBCXX14_CONSTEXPR
      bool
      operator()(const _Tp& __x, const _Tp& __y) const
      { return __x == __y; }
    };

当我们自定义key时，重载equal_to函数时，由于equal_to的比较函数参数和函数体都有const修饰，因此我们重载的比较函数参数和函数体也要有const修饰。

小结：
如果要自定义key，那么要修改两个地方：unordered_map模板类的第三个参数和第四个参数。
（1）Hashing function object type。
（2）Predicate（equal_to） function object type。
（3）重载比较函数时函数参数和函数体const修饰保持不变。

对于typename _Hash = hash<_Key>模板，可以自定义hash模板，也可以特例化原模板所在命名空间的hash模板，即 std：：hash。

三、代码演示API

3.1 自定义哈希模板

#include <string>
#include <iostream>
#include <unordered_map>

 
struct student_id_info
{
    std::string name;
    int arge;
    std::string grade;
 
    student_id_info(std::string a, int b, std::string c) : name(a), arge(b), grade(c){}
    student_id_info(){}
 
 	//相等比较函数
 	//自己提供函数来替代==运算符：operator重载==运算符，当哈希需要处理碰撞时，用来比较结构体student_id_info，比较真正的key值是否相等
 	//简单点说就是多个key的value值在一个桶里（发生哈希碰撞），用来比较其key是否相等
 	//这里重载时参数和函数体的const修饰要与默认比较函数保持不变
    bool operator==(const student_id_info& id) const {
        return name == id.name && arge == id.arge && grade == id.grade;
    }

};
 
 //自己提供的哈希模板
struct hash_fn
{
	//哈希函数
	//重载函数调用符：operator()，函数调用运算符必须是成员函数
    std::size_t operator() (const student_id_info & id) const {
    	//生成name的哈希值
        std::size_t h1 = std::hash<std::string>()(id.name);
        生成arge的哈希值
        std::size_t h2 = std::hash<int>()(id.arge);
        //生成grade的哈希值
        std::size_t h3 = std::hash<std::string>()(id.grade);
        //h1 ^ h2 ^ h3进行异或运算，形成给定的完整的student_id_info哈希值
        //使用异或运算来降低哈希碰撞
        return h1 ^ h2 ^ h3;
    }
};

struct student_score
{
    int math;
    int chinese;
    int english;
 
    student_score(int a, int b, int c) : math(a), chinese(b), english(c){}
    student_score(){}

};

int main()
{
 	//umap多了我们自定义的 哈希模板参数：hash_fn
    std::unordered_map< student_id_info, student_score, hash_fn > umap =
    {
        {{"xiaoming", 18, "freshman"}, {100, 90, 80}},
        {{"xiaohong", 19, "sophomore"}, {95, 90, 85}},
    };
    
    umap.emplace(student_id_info("xiaoli", 20, "Junior year"), student_score(90, 80, 95));

    for (const auto &student: umap)
    {
        std::cout << "{" << student.first.name<< "," << student.first.arge << ","<< student.first.grade <<"}: "
                  << "{" << student.second.math<< "," << student.second.chinese<< ","<< student.second.english <<"}" 
                  << std::endl;
   
    }

    student_id_info s_id = {"xiaohong", 19, "sophomore"};


    if(umap.find(s_id) == umap.end()){
        printf("dont't find the student\n");
    }else{
        printf("student math= %d, chinese = %d, english = %d\n", umap[s_id].math, umap[s_id].chinese, umap[s_id].english);
    }
 
    return 0;
}

结果展示：
在这里插入图片描述

3.2 类模板特例化

#include <string>
#include <iostream>
#include <unordered_map>

struct student_id_info
{
    std::string name;
    int arge;
    std::string grade;
 
    student_id_info(std::string a, int b, std::string c) : name(a), arge(b), grade(c){}
    student_id_info(){}
 
    bool operator==(const student_id_info& id) const {
        return name == id.name && arge == id.arge && grade == id.grade;
    }

};

//打开std命名空间，特例化std::hash
namespace std {
	//定义一个特例化版本
    template<>
    //模板参数为student_id_info
    struct hash<student_id_info>
    {
        std::size_t operator() (const student_id_info & id) const {
            std::size_t h1 = std::hash<std::string>()(id.name);
            std::size_t h2 = std::hash<int>()(id.arge);
            std::size_t h3 = std::hash<std::string>()(id.grade);
            return h1 ^ h2 ^ h3;
        }
    };
}//关闭std命名空间

struct student_score
{
    int math;
    int chinese;
    int english;
 
    student_score(int a, int b, int c) : math(a), chinese(b), english(c){}
    student_score(){}

};

int main()
{
 	//umap没有hash函数参数
    std::unordered_map< student_id_info, student_score > umap =
    {
        {{"xiaoming", 18, "freshman"}, {100, 90, 80}},
        {{"xiaohong", 19, "sophomore"}, {95, 90, 85}},
    };
    
    umap.emplace(student_id_info("xiaoli", 20, "Junior year"), student_score(90, 80, 95));

    for (const auto &student: umap)
    {
        std::cout << "{" << student.first.name<< "," << student.first.arge << ","<< student.first.grade <<"}: "
                  << "{" << student.second.math<< "," << student.second.chinese<< ","<< student.second.english <<"}" 
                  << std::endl;
   
    }

    student_id_info s_id = {"xiaohong", 19, "sophomore"};


    if(umap.find(s_id) == umap.end()){
        printf("dont't find the student\n");
    }else{
        printf("student math= %d, chinese = %d, english = %d\n", umap[s_id].math, umap[s_id].chinese, umap[s_id].english);
    }
 
    return 0;
}

在这里插入图片描述

其中 for (const auto &student: umap) 和 for (const auto student: umap)相比较，前者是引用umap的元素，后者是拷贝umap的元素，前者可以避免更多拷贝。

如果不加const修饰，即for (auto &student: umap) 和 for ( auto student: umap)，前者由于是引用，那么修改student就相当于修改了umap中的元素，而后者仅仅只是拷贝，修改student不会修改umap中的元素。

拷贝的开销远远大于引用。

总结

以上就是unordered_map自定义key结构体方法。

参考资料

c++ primer

https://finixlei.blog.csdn.net/article/details/110267430
https://blog.csdn.net/Histranger_/article/details/120199102

小立爱学习
关注
  • 13
    点赞
  • 踩
  • 28
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
unordered_map和unordered_set的模拟实现
01-20
unordered_map和unordered_set的模拟实现 （一）哈希表的特性及概念 定义： 哈希表（Hash table，也叫散列表），是根据关键字值（key,value）直接进行访问的数据结构。也就是说，它通过把关键字映射到表中一个位置来访问的纪录，以加快查找的速度。这个映射函数叫做散列函数，存放纪录的数组叫散列表。 基本原理： 使用一个下标范围比较大的数组来存储元素。可以设计一个函数（哈希函数，也叫做散列函数），使得每个元素的关键字都与一个函数值（即数组下标，hash值）相对应，于是用这个数组单元来存储这个元素；也可以简单的理解为，按照关键字为每一个元素“分类”，然后将这个元素存储
C++中的哈希容器unordered_map使用示例
12-31
随着C++0x标准的确立，C++的标准库中也终于有了hash table这个东西。 很久以来，STL中都只提供<map>作为存放对应关系的容器，内部通常用红黑树实现，据说原因是二叉平衡树（如红黑树）的各种操作，插入、删除、查找等，都是稳定的时间复杂度，即O(log n)；但是对于hash表来说，由于无法避免re-hash所带来的性能问题，即使大多数情况下hash表的性能非常好，但是re-hash所带来的不稳定性在当时是不能容忍的。 不过由于hash表的性能优势，它的使用面还是很广的，于是第三方的类库基本都提供了支持，比如MSVC中的<hash>和Boost中的<boost/unorde
STL容器之unordered_map类
最新发布
Xpccccc的博客
04-09 469
STL容器之unordered_map类
unordered_map_unordered_map_
09-29
一个C++stl：unordered_map实现实例，用于了解熟悉算法。
C++11 unordered_map与map（插入,遍历，Find）效率对比。
08-24
C++11 unordered_map与map（插入,遍历，Find）效率对比。
关于C++中Hash的应用
weixin_33994429的博客
11-18 362
本文只介绍我们在C++中如何使用Hash这种数据结构达到我们编程的目的，有关Hash的概念和实现不做详谈。 C++11新增了一类散列容器包括unordered_set, unordered_map, unordered_multiset, unordered_multimap， 即之前熟悉的hash_set, hash_map等。 这类容器底层以哈希表实现之，通过unordered_ma...
unordered_map自定义key类型-C++
一点星光
09-27 2153
深入理解unordered_map自定义key类型，从源码的角度分析实现自定义key
C++哈希
zhao19971014的博客
11-14 781
哈希
c++11 map自定义key
小立仔
09-19 3724
map自定义key的方法简介
unordered_map 自定义键值类型
IS_MOKE的博客
08-07 790
C++中的map、unordered_map 排序 对于key的自定义排序 key是结构体的排序 map对于value（值）排序 key是结构体，map对于value（值）排序 unordered_map 自定义key类型 对于value（值）排序
unordered_map自定义key
Alex分享总结
11-30 270
unordered_map使用
C++ STL：unordered_map 自定义键值类型
NBA_1的博客
02-24 2478
unordered_map的定义 下面是unordered_map的官方定义。 template<class Key, class Ty, class Hash = std::hash<Key>, class Pred = std::equal_to<Key>, class Alloc = std::allocator<std::pair<const Key, Ty> > > class unordere.
自定义map的key类型---C++
一点星光
09-29 3026
从源码的角度剖析map的底层key的实现，并分别分析了基础类型key，复合类型key的使用方式。最后，分析了自定义key类型的实现，并且给出了两种实现自定义key类型的方法。
C++ unordered_map/map的key
xiaohuihui1994的博客
09-13 2583
对的
C++(11)：unordered_map
风静如云的博客
02-04 1031
C++11提供了效率更高的unordered_map，他将key做了hash后，以无序的方式对数据进行存储，而之前的map是以红黑树的方式对key排序后进行存储的。unordered_map的特点是查找单个key的速度非常快，且是O(1)的，但是查找一定范围内的key就会比map要慢。如果容器中有这个key，那么可以通过[key]读取到key所对应的值；也可以通过[key] = value，修改容器中key对应的值。需要注意的是[]运算符:map[key]=vlaue。
C++ STL: map自定义键值类型
NBA_1的博客
02-24 1299
map定义 map是STL里的一个模板类，用来存放<key, value>键值对的数据结构，它的定义如下。 template < class Key, //map::key_tpe class T, //map::mapped_type class Compare = less<Key>, .
C++:关联式容器：unordered_map
qq_59535638的博客
06-08 4826
unordered_ map 的特性，常用接口的使用
STL—unordered_map 哈希表
weixin_40535588的博客
05-04 2462
参考：https://blog.csdn.net/hk2291976/article/details/51037095 1.介绍 最近使用到一个c++的容器——unordered_map，它是一个关联容器，内部采用的是hash表结构，拥有快速检索的功能。 1.1 特性 关联性：通过key去检索value，而不是通过绝对地址（和顺序容器不同） 无序性：使用hash表存储，内部无序 M...
自定义类型作为map或者unordered_map的key需要额外做哪些事情
冯同学的博客
06-06 1037
自定义类型作为map或者unordered_map的key需要额外做哪些事情
c++自定义unordered_map
09-24
unordered_map是C++标准库中的一个容器，用于存储键值对，其中的键是唯一的。在unordered_map中，每个键都会关联到一个值，并且可以通过键来快速查找对应的值。unordered_map是通过哈希表实现的，因此查找操作的平均时间复杂度是常数时间。 unordered_map的定义和使用方法如下所示： ```c++ #include <unordered_map> #include <iostream> int main() { // 创建一个unordered_map std::unordered_map<std::string, int> myMap; // 向unordered_map中插入键值对 myMap["apple"] = 1; myMap["banana"] = 2; myMap["orange"] = 3; // 通过键来访问值 std::cout << "Value of apple: " << myMap["apple"] << std::endl; // 遍历unordered_map for (const auto& pair : myMap) { std::cout << "Key: " << pair.first << ", Value: " << pair.second << std::endl; } return 0; } ``` 这段代码演示了如何创建一个存储字符串和整数的unordered_map，并且向其中插入键值对，然后通过键来访问对应的值，并且遍历unordered_map打印出所有的键值对。

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值