c++11 标准模板（STL）（std::unordered_map）（十四）

最新推荐文章于 2024-09-28 03:18:20 发布
最新推荐文章于 2024-09-28 03:18:20 发布
阅读量504 收藏
点赞数 1
分类专栏： # std::unordered_map 文章标签： c++ 哈希算法 unordered_map 无序管理容器 非成员函数
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_40788199/article/details/129450044
版权 
定义于头文件 <unordered_map>
template<

    class Key,
    class T,
    class Hash = std::hash<Key>,
    class KeyEqual = std::equal_to<Key>,
    class Allocator = std::allocator< std::pair<const Key, T> >

> class unordered_map;		(1)(C++11 起)
namespace pmr {

    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>>>;

}		(2)(C++17 起)

 

unordered_map 是关联容器，含有带唯一键的键-值 pair 。搜索、插入和元素移除拥有平均常数时间复杂度。

元素在内部不以任何特定顺序排序，而是组织进桶中。元素放进哪个桶完全依赖于其键的哈希。这允许对单独元素的快速访问，因为一旦计算哈希，则它准确指代元素所放进的桶。

 

观察器

返回用于对关键哈希的函数

std::unordered_map<Key,T,Hash,KeyEqual,Allocator>::hash_function

hasher hash_function() const;

(C++11 起)

 返回对关键哈希的函数。

参数

（无）

返回值

哈希函数。

复杂度

常数。

返回用于比较键的相等性的函数

std::unordered_map<Key,T,Hash,KeyEqual,Allocator>::key_eq

key_equal key_eq() const;

(C++11 起)

 返回比较关键相等性的函数。

参数

（无）

返回值

关键比较函数。

复杂度

常数。

非成员函数

比较 unordered_map 中的值

operator==,!=(std::unordered_map)
template< class Key, class T, class Hash, class KeyEqual, class Allocator >

bool operator==( const unordered_map<Key,T,Hash,KeyEqual,Allocator>& lhs,

                 const unordered_map<Key,T,Hash,KeyEqual,Allocator>& rhs );		(1)
template< class Key, class T, class Hash, class KeyEqual, class Allocator >

bool operator!=( const unordered_map<Key,T,Hash,KeyEqual,Allocator>& lhs,

                 const unordered_map<Key,T,Hash,KeyEqual,Allocator>& rhs );		(2)

 比较二个无序容器的内容。

若下列条件成立则二个无序容器 lhs 与 rhs 相等：

  • lhs.size() == rhs.size()
  • 从 lhs.equal_range(lhs_eq1) 获得的每组等价元素 [lhs_eq1, lhs_eq2) 拥有在另一容器中从 rhs.equal_range(rhs_eq1) 获得的对应等价元素组 [rhs_eq1, rhs_eq2) ，且它们拥有下列属性：
  • std::distance(lhs_eq1, lhs_eq2) == std::distance(rhs_eq1, rhs_eq2) 。
  • std::is_permutation(lhs_eq1, lhs_eq2, rhs_eq1) == true 。

若 Key 或 T 不可相等比较 (EqualityComparable) 则行为未定义。

若 hash_function() 和 key_eq() (C++20 前)key_eq() (C++20 起) 在 lhs 和 rhs 上拥有不相同的行为，或若 Key 的 operator== 不是对于 key_eq() 所引入的等价关键组的细分（即若用 operator== 比较相等的二个元素落入不同划分），则行为未定义。

参数

lhs, rhs-要比较的无序容器

返回值

1) 若容器内容相等则为 true ，否则为 false 。

2) 若容器内容不相等则为 true ，否则为 false 。

复杂度

调用 value_type 上的 operator== 、调用 key_eq 所返回的谓词，及调用 hash_function 所返回的哈希器的次数，平均情况下与 N 成比例，最坏情况下与 N2 成比例，其中 N 是容器大小。

特化 std::swap 算法

std::swap(std::unordered_map
template< class Key, class T, class Hash, class KeyEqual, class Alloc >

void swap( unordered_map<Key,T,Hash,KeyEqual,Alloc>& lhs,

           unordered_map<Key,T,Hash,KeyEqual,Alloc>& rhs );		(C++11 起)
(C++17 前)
template< class Key, class T, class Hash, class KeyEqual, class Alloc >

void swap( unordered_map<Key,T,Hash,KeyEqual,Alloc>& lhs,

           unordered_map<Key,T,Hash,KeyEqual,Alloc>& rhs ) noexcept(/* see below */);		(C++17 起)

 为 std::unordered_map 特化 std::swap 算法。交换 lhs 与 rhs 的内容。调用 lhs.swap(rhs) 。

参数

lhs, rhs-要交换内容的容器

返回值

（无）

复杂度

常数。

异常

noexcept 规定：  

noexcept(noexcept(lhs.swap(rhs)))

(C++17 起)

 

调用示例 

#include <iostream>
#include <forward_list>
#include <string>
#include <iterator>
#include <algorithm>
#include <functional>
#include <unordered_map>
#include <time.h>

using namespace std;

struct Cell
{
    int x;
    int y;

    Cell() = default;
    Cell(int a, int b): x(a), y(b) {}

    Cell &operator +=(const Cell &cell)
    {
        x += cell.x;
        y += cell.y;
        return *this;
    }

    Cell &operator +(const Cell &cell)
    {
        x += cell.x;
        y += cell.y;
        return *this;
    }

    Cell &operator *(const Cell &cell)
    {
        x *= cell.x;
        y *= cell.y;
        return *this;
    }

    Cell &operator ++()
    {
        x += 1;
        y += 1;
        return *this;
    }


    bool operator <(const Cell &cell) const
    {
        if (x == cell.x)
        {
            return y < cell.y;
        }
        else
        {
            return x < cell.x;
        }
    }

    bool operator >(const Cell &cell) const
    {
        if (x == cell.x)
        {
            return y > cell.y;
        }
        else
        {
            return x > cell.x;
        }
    }

    bool operator ==(const Cell &cell) const
    {
        return x == cell.x && y == cell.y;
    }
};

struct myCompare
{
    bool operator()(const int &a, const int &b)
    {
        return a < b;
    }
};

std::ostream &operator<<(std::ostream &os, const Cell &cell)
{
    os << "{" << cell.x << "," << cell.y << "}";
    return os;
}

std::ostream &operator<<(std::ostream &os, const std::pair<Cell, string> &pCell)
{
    os << pCell.first << "-" << pCell.second;
    return os;
}

struct CHash
{
    size_t operator()(const Cell& cell) const
    {
        size_t thash = std::hash<int>()(cell.x) | std::hash<int>()(cell.y);
//        std::cout << "CHash: " << thash << std::endl;
        return thash;
    }
};

struct CEqual
{
    bool operator()(const Cell &a, const Cell &b) const
    {
        return a.x == b.x && a.y == b.y;
    }
};

int main()
{
    std::cout << std::boolalpha;

    std::mt19937 g{std::random_device{}()};
    srand((unsigned)time(NULL));

    auto generate = []()
    {
        int n = std::rand() % 10 + 110;
        Cell cell{n, n};
        return std::pair<Cell, string>(cell, std::to_string(n));
    };

    std::unordered_map<Cell, string, CHash, CEqual> unordered_map1;
    while (unordered_map1.size() < 5)
    {
        //6) 插入来自 initializer_list ilist 的元素。若范围中的多个元素拥有比较等价的关键，则插入哪个元素是未指定的
        unordered_map1.insert({generate()});
    }

    std::cout << "unordered_map1:   ";
    std::copy(unordered_map1.begin(), unordered_map1.end(),
              std::ostream_iterator<pair<Cell, string>>(std::cout, " "));
    std::cout << std::endl;

    std::unordered_map<Cell, string, CHash, CEqual> unordered_map2;
    while (unordered_map2.size() < 5)
    {
        //6) 插入来自 initializer_list ilist 的元素。若范围中的多个元素拥有比较等价的关键，则插入哪个元素是未指定的
        unordered_map2.insert({generate()});
    }

    std::cout << "unordered_map2:   ";
    std::copy(unordered_map2.begin(), unordered_map2.end(),
              std::ostream_iterator<pair<Cell, string>>(std::cout, " "));
    std::cout << std::endl;
    std::cout << std::endl;


    //比较二个无序容器的内容。
    std::cout << "unordered_map1 == unordered_map2: " << (unordered_map1 == unordered_map2) << std::endl;
    std::cout << "unordered_map1 != unordered_map2: " << (unordered_map1 != unordered_map2) << std::endl;
    std::cout << std::endl;


    //为 std::unordered_map 特化 std::swap 算法。交换 lhs 与 rhs 的内容。调用 lhs.swap(rhs) 。
    std::swap(unordered_map1, unordered_map2);
    std::cout << "after swap:   " << std::endl;
    std::cout << "unordered_map1:   ";
    std::copy(unordered_map1.begin(), unordered_map1.end(),
              std::ostream_iterator<pair<Cell, string>>(std::cout, " "));
    std::cout << std::endl;
    std::cout << "unordered_map2:   ";
    std::copy(unordered_map2.begin(), unordered_map2.end(),
              std::ostream_iterator<pair<Cell, string>>(std::cout, " "));
    std::cout << std::endl;

    return 0;
}

第四十五节 C++ STL（标准模板库）-映射类std::map std::multimap std::unordered_map std::unordered_multimap
菜鸟博客
05-01 927
map的操作与set类似，操作可参考上一节，这里仅介绍基本操作映射类： 为key-value(键-值)对容器, 支持根据key查找value， 如根据int可查找对应的stringstd::map: 存储唯一的键, 默认从小到大排序std::mulitmap: 可存储重复的键 ， 默认从小到大排序 std::unordered_map: 用散列函数排序，键唯一 std::unordered_mul...
C++语法—— STL:unordered_map
观则明的博客
10-23 6832
C++语法—— STL:unordered_map
unordered_map的哈希模板
weixin_43823753的博客
11-17 138
模板来源：HKer_YM的博客 struct custom_hash { static uint64_t splitmix64(uint64_t x) { x += 0x9e3779b97f4a7c15; x = (x ^ (x >> 30)) * 0xbf58476d1ce4e5b9; x = (x ^ (x >> 27)) * 0x94d049bb133111eb; return x ^ (x >&g
HASH 模板和题目总结（包括unordered_map）
pxlsdz的博客
08-08 561
目录 HASH表（不是重点） STL——unordered_map 定义 基本操作 进阶操作 与map优缺点： map： unordered_map： 总结： 字符串hash 定义： 具体实现： 字符串任意子串的Hash 二维模板（具体原理BZOJ2351Matrix （矩阵） 二维哈希） 例题 HASH表（不是重点） 模拟哈希表主要有两种方法：拉链法...
C++11 map
wangxu696200的博客
03-11 724
C++ map
hash_map和unordered_map的使用
交流学习实践
11-14 1135
哈希表又名散列表，它可以帮助我们gaoxiao
【C++】std::map、std::unordered_map详解
lemonxiaoxiao的博客
08-26 4087
容器是存放数据的地方，常见的容器有：序列式容器和关联式容器。序列式容器，即其中的元素不一定有序，但可以被排序，比如：vector、list、queue、stack、heap、priority_queue；而关联式容器内部结构基本上是一个平衡二叉树。所谓关联，指每个元素都有一个键值和一个实值<key,value>，元素按照一定的规则存放，比如：RB-tree、set、map、unordered_map、hashtable、hash_map、hash_set。 一、map / multimap .
C++ STL 无序容器std::unordered_map
南宫萧幕的博客
01-17 2519
文章目录std::unordered_map创建 unordered_map 容器成员方法无序容器的底层实现机制成员方法获取元素的 4 种方法insert() 用法emplace() 和 emplace_hint() 方法删除元素 erase()/clear()erase()clear() std::unordered_map unordered_map 容器和 map 容器仅有一点不同,即 map 容器中存储的数据是有序的,而 unordered_map 容器中是无序的。 unordered_ma
深入剖析 std::unordered_map 的实现原理之 Hash冲突、退化
loOK后端
02-27 8729
本次来讲解下c++中 std::unordered_map的设计原理。 std::unordered_map里面has-a哈希表，它提供的的各个方法基本都是由hashtable封装实现，因此在下文使用hashtable来描述std::unordered_map。 // gnu 实现 template<typename _Key, typename _Tp, typename _Hash = hash<_Key>,
《 C++ 修炼全景指南：二十 》为什么你的代码不够快？全面掌控 unordered_set 和 unordered_map 的哈希性能飙升魔法
最新发布
Lenyiin
09-28 5615
本文深入探讨了 C++ 标准库中的两大无序容器——unordered_set 和 unordered_map，从底层实现、核心操作、性能优化、实际应用等多个方面进行了全面分析。首先，文章介绍了这两种容器的基本概念，说明了它们基于哈希表实现的特点，尤其是在查找、插入和删除操作上具备常数时间复杂度的优势。接着，文章对比了有序容器和无序容器，指出了在不同应用场景下的适用性。 通过对哈希表封装的分析，文章详细讲解了插入、查找和删除操作的底层实现，并阐述了如何通过优化哈希函数、负载因子和重哈希机制来提升
C++ unordered_map容器在const修饰下将无法使用“[]“来获取键值
qq_45786156的博客
12-06 1720
C++ unordered_map容器在const修饰下将无法使用"[]"来获取键值 在写代码中发现这个现象。（可推及至一切Map衍生的容器） **解释：**对于const的对象使用了非const的成员函数：std::map::[]本身不是const成员函数（操作符），对于不在map中的关键字，使用下标操作符会创建新的条目，改变了map。 解决方法： std::unordered_map.at(digit); ...
unordered_map详解
qq_44423388的博客
09-13 1万+
unordered_map 是关联容器，含有带唯一键的键(key;it->first)-值(value;it->second) pair 。搜索、插入和元素移除拥有平均常数时间复杂度。 元素在内部不以任何特定顺序排序，而是组织进桶中。元素放进哪个桶完全依赖于其键的哈希。这允许对单独元素的快速访问，因为一旦计算哈希，则它准确指代元素所放进的桶。
unordered_map []与const
ccy_8491的博客
12-16 1526
在某次编译时报错error:passing'conststd::unordered_map<std::basic_string<char>,std::basic_string<char>>'as'this'argumentdiscardsqualifiers[-fpermissive]，代码为： void test(const std::unordered_map<std::string, std::string>& d) {...
c++ unordered_map容器函数说明
Mr____DAI的博客
03-16 504
【代码】c++ unordered_map容器函数说明。
【C++】-- STL之unordered_map/unordered_set详解
局部变量和全局变量
09-13 2562
STL有两种容器:序列式容器和关联式容器，序列式容器vetor/lost/deque，用来存储数据。关联式容器map/set/unordered_map/unordered_set用来存储数据+查找数据。 unordered_map和unordered_set是c++里面两个提供哈希表的容器，map和set底层是红黑树，unordered_map和unordered_set的底层是哈希表（散列表），是一种映射。
C++: unordered_map常见用法
道纪书生的博客
08-26 9073
1. 头文件 #include <unordered_map> 2. 初始化 unordered_map<char, int>; 3. 插入元素 //数组形式 map['a'] = 1; //直接插入 map.insert( { {'b',2} , {'c',3} } ); 4. 修改元素 map['a'] = 0; 5. 删除元素 //删除key为'a'的元素 map.erase('a'); //删除第一个元素 map.erase(map.begi
C++ STL标准模板库-优秀的C++标准库
08-23
STL是Standard Template Library的简称，中文名标准模板库，是由Alexander Stepanov、Meng Lee和David R Musser在惠普实验室开发的 ，是一个具有工业强度的，高效的C++库，STL早已是ANSI/ISO C++标准中的一部分。STL库由于其对跨平台，对标准C++的支持，开源，高效等优点，如今已经被广泛运用于企业级开发。
C++中的unordered_map常见用法详解
热门推荐
学习永无止境
01-25 2万+
文章目录 1. std::unordered_map 的定义与特性2. 构造 std::unordered_map3. 赋值操作4. 迭代器操作4.1 指向整个容器中的元素4.2 指向某个桶中的元素 5. 容量操作6. 访问操作7. 插入操作8. 删除操作9. 查找操作10. 桶操作 1. std::unordered_map 的定义与特性 所在头文件：<unordered_map> std::unorederd_map类模板： template < class K.
unordered_map的介绍及使用
gp1330782530的博客
05-28 7069
unordered_map的介绍及使用 1、unordered_map的介绍 1、unordered_map是存储<key, value>键值对的关联式容器，其允许通过key快速的索引到与其对应的value 2、unordered_map中，键值通常用于惟一的标识元素，而映射值是一个对象，其内容与此键关联，键和映射的类型可以不同 3、在内部，unordered_map没有对<key, value>进行排序，unordered_map将相同哈希值的键值对放在对应的桶中 4、unord
std::unordered_set和std::unordered_map
10-19
std::unordered_set和std::unordered_map是C++ STL库中的两个容器，它们都是基于哈希表实现的。其中，std::unordered_set是一个无序的集合，它存储唯一的元素，而std::unordered_map是一个无序的关联数组，它存储键值对。这两个容器都比std::set和std::map更高效，因为它们的元素是通过哈希函数进行快速查找的，而不是通过比较函数进行查找的。 在使用std::unordered_set时，可以使用构造函数来初始化容器，并将元素插入到容器中。例如，可以使用以下代码初始化一个std::unordered_set并将"aaa"、"bbb"和"ccc"插入到容器中： std::unordered_set<std::string> c{ "aaa", "bbb", "ccc" }; 另外，也可以使用以下代码初始化一个具有16个桶的std::unordered_set： std::unordered_set<std::string> c{ 16 }; 在使用std::unordered_map时，可以使用insert()函数将键值对插入到容器中，也可以使用[]运算符来访问和修改元素。此外，还可以使用find()函数来查找特定的键是否存在于容器中。例如，可以使用以下代码查找键为key的元素是否存在于std::unordered_map中： auto it = mymap.find(key); if (it != mymap.end()) { // key存在于mymap中 } else { // key不存在于mymap中 }
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值