C++ 关联式容器之unordered_map

柔光的暖阳◎ 2023-07-06 09:49 12阅读 0赞

# STL 关联式容器 #

**目录**

STL 关联式容器

unordered\_map

常用接口介绍

1.常见构造

3.容量操作

4. unordered\_map的修改操作

5. 元素访问与查询

6. unordered\_map的桶操作

常见接口实现

--------------------

**简介**

> 说到 **关联式容器**,  需要区分是**序列式容器**, 例如vector, list, deque等都是序列式容器, 序列式其特点都体现在 "序列"上 .
> 
> 序列式容器中存储元素是线性排布的, 在进行查找搜索时效率较低. 序列式容器并不会对插入元素进行任何方式的重新排序,
> 
> 插入在哪个位置就在哪个位置 .
> 
> 关联式容器, 特点也体现在 "关联"上, 关联式容器通过**键值对(包括key和value)**, 将存储的每一个数据value与一个键值key一
> 
> 一对应起来, 只需要通过键值key就可以读写元素, 在查找搜索时效率高.
> 
> 关联式容器分为两种, **有序和无序(unordered)**的, C++98中, STL只有底层用**红黑树**实现的有序的关联式容器包括map, set,
> 
> multimap, multiset. 这四个容器会将插入的元素按特定顺序存储(并不是像序列式容器一样存在哪个位置就在哪个位置, 而是
> 
> 存元素的位置可能会还会进行调整), 以保证红黑树的平衡, 进而实现了log₂N的查询效率, 即最坏情况也只需要查询红黑树的
> 
> 树高次. 但log₂N的时间复杂度毕竟不是常数, 当数据量特别大时, 也会比较耗时. 
> 
> 所以,  在C++11中, STL中又新增了4个 unordered系列的(无序的)关联式容器, 包括  unordered\_map, unordered\_set,
> 
> unordered\_multimap, unordered\_multiset. 它们的底层是用**哈希表(散列表)**来实现的, 即 将键值key值映射到表中一个位置来
> 
> 访问value. 所以不会按照某种顺序来存储元素, 即是无序的,  在不发生**哈希冲突****(碰撞)**时查询效率可达到O(1) .

关于哈希详细写在另一篇博客,[戳链接（￣︶￣）↗ https://blog.csdn.net/qq\_41071068/article/details/104475643][https_blog.csdn.net_qq_41071068_article_details_104475643]

# unordered\_map #

在线说明文档,[戳链接（￣︶￣）↗ ][Link 1][http://www.cplusplus.com/reference/unordered\_map/unordered\_map/][Link 1]

**简介**

> 1. 头文件 \#include<unordered\_map>
> 
> 2. unordered\_map存储的是<key, value>键值对, 可以直接通过key快速访问到其对应的value, 与map保持一致
> 
> 3. unordered\_map中key用来唯一的标识元素, 所以, key是唯一的, 即不同元素的value可以相同或不同, 但key必定是不同的
> 
>     这一点与map保持一致.
> 
> 4. 在unordered\_map 内并没有对<kye, value>按照任何特定的顺序排序, 为了能在时间复杂度是常数范围内找到key所对应
> 
>     的value，unordered\_map将相同哈希值的键值对放在相同的桶中 . 与map不同
> 
> 5. unordered\_map容器通过key访问单个元素要比map快 .但unordered\_map在元素子集的范围迭代上效率不如map. 这都是
> 
>     有他们各自的底层结构决定的.
> 
> 6. template<K, T, Hash, Pred, Alloc>  
>     class unordered\_map;
> 
>     template < class K,                                      //键值key的类型
>                class T,                                      //数据Value的类型
>                class Hash = hash<Key>,                       /*用于将K类型的Key转换成一个size_t类
>                                                                型的唯一值并返回, 用作哈希函数的参数
>                                                                可以是仿函数或函数指针*/
>                class Pred = equal_to<Key>,                   /*返回pair<K, T>(key, Value)元素的first
>                                                                也就是key, 可以是仿函数或函数指针*/
>                class Alloc = allocator< pair<const Key,T> >  //空间配置器
>                > 
>     class unordered_map;

**键值对**

SGI-STL中关于键值对的定义：

template <class T1, class T2>
    struct pair {
        typedef T1 first_type;
        typedef T2 second_type;
        T1 first;
        T2 second;
        pair() : 
            first(T1()),
            second(T2())
        {}
        pair(const T1& a, const T2& b)
            : first(a), second(b)
        {}
    };

pair用来将key和value合并为一个键值对, 其中first就是key, second就是value .

## 常用接口介绍 ##

### **1.常见构造** ###

<table> 
 <thead> 
  <tr> 
   <th style="text-align:center;width:463px;">构造方式</th> 
   <th style="text-align:center;width:335px;">功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <th style="text-align:center;width:463px;">unordered_map( );</th> 
   <td style="text-align:center;width:335px;">构造空的unordered_map</td> 
  </tr> 
  <tr> 
   <th style="text-align:center;width:463px;"> <p>template &lt;class InputIterator&gt; &nbsp;</p> <p>&nbsp; &nbsp; &nbsp; unordered_map ( InputIterator first, InputIterator last)</p> </th> 
   <td style="text-align:center;width:335px;">用 <strong>[ first,last )</strong> 区间中的元素构造unordered_map</td> 
  </tr> 
  <tr> 
   <th style="text-align:center;width:463px;">unordered_map ( const unordered_map&amp; ump )</th> 
   <td style="text-align:center;width:335px;">拷贝构造</td> 
  </tr> 
  <tr> 
   <th style="text-align:center;width:463px;">unordered_map ( initializer_list&lt;value_type&gt; il)</th> 
   <td style="text-align:center;width:335px;">初始化列表构造</td> 
  </tr> 
 </tbody> 
</table>

**2. unordered\_map  iterator(迭代器)的使用**

<table style="width:600px;"> 
 <thead> 
  <tr> 
   <th style="text-align:center;">函数声明</th> 
   <th style="text-align:center;">功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <th style="text-align:center;">begin( )</th> 
   <td style="text-align:center;">返回第一个元素位置的iterator</td> 
  </tr> 
  <tr> 
   <th style="text-align:center;">end( )</th> 
   <td style="text-align:center;">返回最后一个元素后一个位置的iterator</td> 
  </tr> 
  <tr> 
   <th style="text-align:center;">cbegin( )</th> 
   <td style="text-align:center;">返回第一个元素位置的const_iterator</td> 
  </tr> 
  <tr> 
   <th style="text-align:center;">cend( )</th> 
   <td style="text-align:center;">返回最后一个元素后一个位置的const_iterator</td> 
  </tr> 
 </tbody> 
</table>

具体用法 :

#include<iostream>
    #include<unordered_map>
    using namespace std;
    void test1() {
    	pair<int, int> p1(1, 2);
    	pair<int, int> p2(3, 4);
    	pair<int, int> p3(5, 6);
    	pair<int, int> p4(7, 8);
    	unordered_map<int, int> mp1;
    	unordered_map<int, int> mp2 = { p1, p2, p3, p4 };
    	unordered_map<int, int> mp3(mp2);
    	unordered_map<int, int> mp4(mp2.begin(), mp2.end());
    	unordered_map<int, int>::iterator i;
    	cout << "mp2:\n";
    	for (i = mp2.begin(); i != mp2.end(); ++i) {
    		cout << (*i).first << ' ' << (*i).second << endl;
    	}
    	cout << "mp3:\n";
    	for (i = mp3.begin(); i != mp3.end(); ++i) {
    		cout << (*i).first << ' ' << (*i).second << endl;
    	}
    	cout << "mp4:\n";
    	for (i = mp4.begin(); i != mp4.end(); ++i) {
    		cout << (*i).first << ' ' << (*i).second << endl;
    	}
    }
    int main() {
    	test1();
    	return 0;
    }

![20200223181336597.png][]

### 3.**容量操作** ###

<table style="width:600px;"> 
 <thead> 
  <tr> 
   <th style="text-align:center;">函数申明</th> 
   <th style="text-align:center;">功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <th style="text-align:center;">size_t size( )</th> 
   <td style="text-align:center;">返回元素的个数</td> 
  </tr> 
  <tr> 
   <th style="text-align:center;">bool empty( )</th> 
   <td style="text-align:center;">检测是否为空</td> 
  </tr> 
 </tbody> 
</table>

### **4. unordered\_map的修改操作** ###

<table style="width:700px;"> 
 <thead> 
  <tr> 
   <th style="text-align:center;width:422px;">函数申明</th> 
   <th style="text-align:center;width:276px;">功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <th style="text-align:center;width:422px;"> <p>pair&lt;iterator,bool&gt; insert ( const value_type&amp; val ); &nbsp;</p> <p>template &lt;class InputIterator&gt; &nbsp; &nbsp;</p> <p>&nbsp; &nbsp; &nbsp; &nbsp; &nbsp;void insert ( InputIterator first, InputIterator last ); &nbsp;</p> <p>void insert ( initializer_list&lt;value_type&gt; il );</p> </th> 
   <td style="text-align:center;width:276px;"> <p>&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;插入元素val</p> <p>&nbsp;</p> <p>&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; 插入[first, last)范围内的元素</p> <p>&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;插入参数列表中得值</p> </td> 
  </tr> 
  <tr> 
   <th style="text-align:center;width:422px;"> <p>iterator erase ( const_iterator position );</p> <p>size_type erase ( const key_type&amp; k );</p> <p>iterator erase ( const_iterator first, const_iterator last );</p> </th> 
   <td style="text-align:center;width:276px;"> <p>&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;删除postion位置处的元素</p> <p>&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp;删除键值为k的元素</p> <p>&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; 删除[first, last)范围内的元素</p> </td> 
  </tr> 
  <tr> 
   <th style="text-align:center;width:422px;">void clear( );</th> 
   <td style="text-align:center;width:276px;">清空容器中的所有元素</td> 
  </tr> 
  <tr> 
   <th style="text-align:center;width:422px;">void swap(unordered_map&amp; ump)</th> 
   <td style="text-align:center;width:276px;">交换两个容器中的元素</td> 
  </tr> 
 </tbody> 
</table>

**关于迭代器失效的问题:**

当insert后, 如发生扩容, 则之前所有元素的迭代器都会失效. 如不发生扩容, 则不会失效.

当erase后, 迭代器一定会失效

### **5. 元素访问与查询** ###

<table style="width:600px;"> 
 <thead> 
  <tr> 
   <th style="text-align:center;width:329px;">函数申明</th> 
   <th style="text-align:center;width:269px;">功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <th style="text-align:center;width:329px;"> <p>&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; T&amp; operator[](const K&amp; key);</p> <p>&nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; &nbsp; T&amp; operator[](K&amp;&amp; key);</p> </th> 
   <td style="text-align:center;width:269px;">返回与key对应的value的引用, 如果没有则插入(key, T()), 并返回value的引用</td> 
  </tr> 
  <tr> 
   <th style="text-align:center;width:329px;">T&amp; at(const K&amp; key);</th> 
   <td style="text-align:center;width:269px;"> <p>返回与key对应的value的引用,如果没有则抛出异常</p> </td> 
  </tr> 
  <tr> 
   <th style="text-align:center;width:329px;">size_t count(const K&amp; key);</th> 
   <td style="text-align:center;width:269px;">返回哈希桶中关键码为key的键值对的个数,unordered_map中要么为1要么为0</td> 
  </tr> 
  <tr> 
   <th style="text-align:center;width:329px;">iterator find(const K&amp; key)</th> 
   <td style="text-align:center;width:269px;">返回key在哈希桶中的位置</td> 
  </tr> 
 </tbody> 
</table>

值得注意的是 \[\] 重载, 当存在于key所对应的value时, 返回value的引用, 当不存在时, 则插入(key, T())到容器中, T()是value的默认

构造. 还有就是at()与\[ \]重载不同的是, 当key没有对应的value时, at()会抛出异常

### 6. unordered\_map的桶操作 ###

<table style="width:500px;"> 
 <thead> 
  <tr> 
   <th style="text-align:center;">函数申明</th> 
   <th style="text-align:center;">功能</th> 
  </tr> 
 </thead> 
 <tbody> 
  <tr> 
   <th style="text-align:center;">size_t bucket_count()const &nbsp;</th> 
   <td style="text-align:center;">返回哈希桶中桶的总个数&nbsp;</td> 
  </tr> 
  <tr> 
   <th style="text-align:center;">size_t bucket_size(size_t n)const</th> 
   <td style="text-align:center;">返回n号桶中有效元素的总个数</td> 
  </tr> 
  <tr> 
   <th style="text-align:center;">size_t bucket(const K&amp; key)</th> 
   <td style="text-align:center;">返回元素key所在的桶号</td> 
  </tr> 
 </tbody> 
</table>

## 常见接口实现 ##

unordered\_map只是对哈希桶的一个封装, 所以首先得实现一个哈希桶, 如下:

***HashBucket.h***

#pragma once
    #include<vector>
    using namespace std;
    
    template <class V>
    class HashBucketNode {
    public:
    	V m_val;
    	HashBucketNode * m_next;
    	HashBucketNode(const V& val = V()) :
    		m_val(val),
    		m_next(nullptr)
    	{}
    
    	template<class K, class V, class KeyOfVal, class HF>
    	friend class Iterator;
    
    	template<class K, class V, class KeyOfVal, class HF>
    	friend class HashBucket;
    };
    class dealInt {
    public:
    	int operator()(const int& key) {
    		return key;
    	}
    };
    
    template<class K, class V, class KeyOfVal, class HF = dealInt>
    class Iterator {
    public:
    	HashBucket<K, V, KeyOfVal, HF>* m_hbpos;//直到桶在哪儿, 方便找上一个或下一个桶
    	HashBucketNode<V>* m_node;//具体节点
    	Iterator(HashBucket<K, V, KeyOfVal, HF>* hbpos = nullptr, HashBucketNode<V>* node = nullptr) :
    		m_hbpos(hbpos),
    		m_node(node)
    	{}
    
    	Iterator(const Iterator& it) :
    		m_hbpos(it.m_hbpos),
    		m_node(it.m_node)
    	{}
    
    	V& operator*() {
    		return m_node->m_val;
    	}
    
    	V* operator->() {
    		return &(m_node->m_val);
    	}
    
    	Iterator operator++() {
    		HashBucketNode<V>* t = m_node;
    		m_node = m_node->m_next;
    		if (!m_node) {//为空
    			size_t tmp = m_hbpos->HashFunc(KeyOfVal()(t->m_val)) + 1;//下一个桶的下标
    			for (; tmp < m_hbpos->capacity(); ++tmp) {
    				if (m_hbpos->m_table[tmp]) {
    					m_node = m_hbpos->m_table[tmp];
    					break;
    				}
    			}
    		}
    		return *this;
    	}
    
    	Iterator operator++(int) {
    		Iterator tmp = *this;
    		this->operator++();
    		return tmp;
    	}
    
    	bool operator==(const Iterator& data) const {
    		return m_node == data.m_node;
    	}
    
    	bool operator!=(const Iterator& data) const {
    		return m_node != data.m_node;
    	}
    };
    template<class K, class V, class KeyOfVal, class HF = dealInt>
    class HashBucket {
    	vector<HashBucketNode<V>*> m_table;
    	size_t m_size;
    	static size_t s_m_primeTable[30];
    	size_t m_primePos;
    
    	template<class K, class V, class KeyOfVal, class HF>
    	friend class Iterator;
    
    	typedef Iterator<K, V, KeyOfVal, HF> Iterator;
    
    	size_t HashFunc(const K& key) {
    		return HF()(key) % capacity();
    	}
    
    	void checkCapacity() {
    		int oldcapacity = capacity();
    		if (oldcapacity == m_size) {//此时哈希冲突发生概率100%, 此时扩容
    			vector<HashBucketNode<V>*> tmp(s_m_primeTable[++m_primePos]);
    			m_table.swap(tmp);
    			m_size = 0;
    
    			for (auto e : tmp) {
    				for (; e; e = e->m_next) {
    					insert(e->m_val);
    				}
    			}
    		}
    	}
    public:
    	HashBucket(const size_t capacity = s_m_primeTable[0]) :
    		m_table(capacity, nullptr),
    		m_size(0),
    		m_primePos(0)
    	{}
    
    	~HashBucket() {
    		clear();
    	}
    
    	size_t capacity() {
    		return m_table.size();
    		//return s_m_primeTable[m_primePos];
    	}
    	Iterator begin() {
    		for (size_t i = 0; i < capacity(); ++i) {
    			if (m_table[i]) {
    				return Iterator(this, m_table[i]);
    			}
    		}
    		return Iterator(this, nullptr);
    	}
    	Iterator end() {
    		return Iterator(this, nullptr);
    	}
    	pair<Iterator, bool> insert(const V& val) {
    		checkCapacity();//首先检查是否需要扩容
    		int k = HashFunc(KeyOfVal()(val));
    		HashBucketNode<V>* cur = m_table[k];
    		while (cur) {
    			if (KeyOfVal()(cur->m_val) == KeyOfVal()(val)) {
    				return pair<Iterator, bool>(Iterator(this, cur), false);
    			}
    			cur = cur->m_next;
    		}
    		cur = new HashBucketNode<V>(val);
    		cur->m_next = m_table[k];
    		m_table[k] = cur;
    		++m_size;
    		return pair<Iterator, bool>(Iterator(this, m_table[k]), true);//因为是头插, 所以返回头
    	}
    
    	Iterator find(const K& Keyval) {
    		int k = HashFunc(Keyval);
    		HashBucketNode<V>* cur;
    		for (cur = m_table[k]; cur; cur = cur->m_next) {
    			if (KeyOfVal()(cur->m_val) == Keyval) {
    				break;
    			}
    		}
    		return Iterator(this, cur);
    	}
    
    	pair<Iterator, bool> erase(const K& Keyval) {
    		Iterator f = find(Keyval);
    		int n = HashFunc(Keyval);
    		if (f.m_node) {
    			Iterator tmp = f;
    			if (m_table[n] == f.m_node) {
    				m_table[n] = m_table[n]->m_next;
    			}
    			else {
    				for (HashBucketNode<V>* cur = m_table[n]; cur->m_next; cur = cur->m_next) {
    					if (cur->m_next == f.m_node) {
    						cur->m_next = cur->m_next->m_next;
    						break;
    					}
    				}
    			}
    			++tmp;
    			delete f.m_node;
    			--m_size;
    			return pair<Iterator, bool>(tmp, true);
    		}
    		return pair<Iterator, bool>(Iterator(this, nullptr), false);
    	}
    
    	size_t size() {
    		return m_size;
    	}
    	bool empty() {
    		return 0 == m_size;
    	}
    	void clear() {
    		HashBucketNode<V>* tmp;
    		m_size = 0;
    		for (auto head : m_table) {
    			while (head) {
    				tmp = head;
    				head = head->m_next;
    				delete tmp;
    			}
    		}
    		for (auto& e : m_table) {
    			e = nullptr;
    		}
    	}
    	size_t bucket_count()const {//返回哈希桶中桶的个数
    		size_t count = 0;
    		for (auto& i : m_table) {
    			if (i != nullptr) {
    				++count;
    			}
    		}
    		return count;
    	}
    	size_t bucket_size(size_t n)const {//返回n号桶中的元素个数
    		size_t count = 0;
    		for (HashBucketNode<V>* i = m_table[n]; i; i = i->m_next) {
    			++count;
    		}
    		return count;
    	}
    	size_t bucket(const K& key) {//返回key对应几号桶
    		return HashFunc(key);
    	}
    };
    template<class K, class V, class KeyofValue, class HF>
    size_t HashBucket<K, V, KeyofValue, HF>::s_m_primeTable[30] = {
    	11, 23, 47, 89, 179,
    	353, 709, 1409, 2819, 5639,
    	11273, 22531, 45061, 90121, 180233,
    	360457, 720899, 1441807, 2883593, 5767169,
    	11534351, 23068673, 46137359, 92274737, 184549429,
    	369098771, 738197549, 1476395029, 2952790016u, 4294967291u
    };

再对HashBucket进行封装.

***unordered\_map.h***

#include"HashBucket.h"
    using namespace std;
    namespace gh {
    	template <class K, class V, class HF = dealInt>
    	class unordered_map {
    		typedef pair<K, V>  ValueType;
    		class KeyOfVal {
    		public:
    			const K& operator()(const ValueType& V) {
    				return V.first;
    			}
    		};
    		typedef HashBucket<K, ValueType, KeyOfVal, HF> HB;
    		HB m_data;
    	public:
    		typedef Iterator<K, ValueType, KeyOfVal, HF> iterator;
    		unordered_map() :m_data(HB()) {}
    		iterator begin() {
    			return m_data.begin();
    		}
    		iterator end() {
    			return m_data.end();
    		}
    		size_t size() {
    			return m_data.size();
    		}
    		bool empty() {
    			return m_data.empty();
    		}
    		void clear() {
    			m_data.clear();
    		}
    		pair<iterator, bool> insert(const ValueType& val) {
    			return m_data.insert(val);
    		}
    		pair<iterator, bool> erase(const K& Keyval) {
    			return m_data.erase(Keyval);
    		}
    		iterator find(const K& Keyval) {
    			return m_data.find(Keyval);
    		}
    		V& operator[](const K& key) {
    			/*pair<iterator, bool> tmp = insert(ValueType(key, V()));
    			iterator tmp2 = tmp.first;
    			return (*tmp2).second;*/
    			return (*insert(ValueType(key, V())).first).second;
    		}
    		const V& operator[](const K& key) const {
    			return (*insert(ValueType(key, V())).first).second;
    		}
    		size_t bucket_count()const {//返回哈希桶中桶的个数
    			return m_data.bucket_count();
    		}
    		size_t bucket_size(size_t n)const {//返回n号桶中的元素个数
    			return m_data.bucket_size(n);
    		}
    		size_t bucket(const K& key) {//返回key对应几号桶
    			return m_data.bucket(key);
    		}
    	};
    };

测试入口, main.cpp

#include<iostream>
    #include"unordered_map.h"
    #include<unordered_map>
    #include"HashBucket.h"
    using namespace std;
    
    class KeyofValueint {
    public:
    	int operator()(int key) {
    		return key;
    	}
    };
    
    void test1() {
    	cout << "test1:\n";
    	HashBucket<int, int, KeyofValueint> hb;
    	hb.insert(6);
    	Iterator<int, int, KeyofValueint> q = hb.insert(9).first;
    	hb.insert(17);
    	hb.insert(16);
    	hb.insert(19);
    	hb.insert(27);
    	hb.insert(61);
    	hb.insert(98);
    	hb.insert(26);
    	hb.insert(63);
    	hb.insert(39);
    	hb.insert(28);
    	pair<Iterator<int, int, KeyofValueint>, bool> p = hb.insert(100);
    	pair<Iterator<int, int, KeyofValueint>, bool> p2 = hb.insert(100);
    	cout << *p.first << endl;
    	p = hb.erase(9);
    	p2 = hb.erase(10101);
    	cout << *p.first << endl << endl;
    	for (auto & e : hb) {
    		cout << e << endl;
    	}
    }
    void test2() {
    	cout << "\ntest2:\n";
    	gh::unordered_map<int, int> ump;
    	ump.insert(pair<int, int>(6, 10));
    	auto q = ump.insert(pair<int, int>(9, 30)).first;
    	ump.insert(pair<int, int>(17, 48));
    	ump.insert(pair<int, int>(16, 32));
    	ump.insert(pair<int, int>(19, 56));
    	ump.insert(pair<int, int>(27, 89));
    	ump.insert(pair<int, int>(61, 565));
    	ump.insert(pair<int, int>(98, 34));
    	ump.insert(pair<int, int>(26, 78));
    	ump.insert(pair<int, int>(63, 67));
    	ump.insert(pair<int, int>(39, 67));
    	ump.insert(pair<int, int>(28, 67));
    	pair<gh::unordered_map<int, int>::iterator, bool> p = ump.insert(pair<int, int>(100, 89));
    	pair<gh::unordered_map<int, int>::iterator, bool> p2 = ump.insert(pair<int, int>(100, 23));
    	cout << (*(p.first)).first << "  " << (*(p.first)).second << endl;
    	p = ump.erase(9);
    	p2 = ump.erase(10101);
    	cout << (*(p.first)).first << "  " << (*(p.first)).second << endl;
    	for (auto & e : ump) {
    		cout << e.first << "  " << e.second << endl;
    	}
    }
    void test3() {
    	gh::unordered_map<int, int> ump;
    	ump.insert(pair<int, int>(6, 10));
    	cout << "\ntest3:\n";
    	cout << ump[6] << endl;
    	cout << ump[10] << endl;
    }
    void test4() {
    	cout << "\ntest4:\n";
    	unordered_map<int, int> ump;
    	ump.insert(pair<int, int>(6, 10));
    	ump.insert(pair<int, int>(17, 12));
    	ump.insert(pair<int, int>(28, 13));
    	auto q = ump.insert(pair<int, int>(9, 30)).first;
    	ump.insert(pair<int, int>(17, 48));
    	ump.insert(pair<int, int>(16, 32));
    	ump.insert(pair<int, int>(19, 56));
    	ump.insert(pair<int, int>(27, 89));
    	ump.insert(pair<int, int>(61, 565));
    	pair<unordered_map<int, int>::iterator, bool> p = ump.insert(pair<int, int>(100, 89));
    	pair<unordered_map<int, int>::iterator, bool> p2 = ump.insert(pair<int, int>(100, 23));
    	cout << (*(p.first)).first << "  " << (*(p.first)).second << endl;
    	size_t a = ump.erase(6);
    	size_t b = ump.erase(17);
    	size_t c = ump.erase(10101);
    	cout << (*(p.first)).first << "  " << (*(p.first)).second << endl;
    	for (auto & e : ump) {
    		cout << e.first << "  " << e.second << endl;
    	}
    }
    void test5() {
    	cout << "\ntest5:\n";
    	gh::unordered_map<int, int> ump;
    	ump.insert(pair<int, int>(6, 10));
    	ump.insert(pair<int, int>(9, 30));
    	ump.insert(pair<int, int>(17, 48));
    	ump.insert(pair<int, int>(16, 32));
    	ump.insert(pair<int, int>(19, 56));
    	ump.insert(pair<int, int>(27, 89));
    	ump.insert(pair<int, int>(61, 565));
    	ump.insert(pair<int, int>(98, 34));
    	ump.insert(pair<int, int>(26, 78));
    	ump.insert(pair<int, int>(63, 67));
    	ump.insert(pair<int, int>(39, 67));
    	ump.insert(pair<int, int>(28, 67));
    	ump.insert(pair<int, int>(100, 89));
    	ump.insert(pair<int, int>(100, 23));
    	cout << ump.bucket_count() << endl;
    	cout << ump.bucket_size(3) << endl;
    	cout << ump.bucket(98) << endl;
    }
    int main() {
    	test1();
    	test2();
    	test3();
    	test4();
    	test5();
    	system("pause");
    	return 0;
    }

结果如下:

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4_size_16_color_FFFFFF_t_70][]

[https_blog.csdn.net_qq_41071068_article_details_104475643]: https://blog.csdn.net/qq_41071068/article/details/104475643
[Link 1]: http://www.cplusplus.com/reference/unordered_map/unordered_map/
[20200223181336597.png]: https://img-blog.csdnimg.cn/20200223181336597.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4_size_16_color_FFFFFF_t_70]: https://img-blog.csdnimg.cn/20200223211122858.png?x-oss-process=image/watermark,type_ZmFuZ3poZW5naGVpdGk,shadow_10,text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3FxXzQxMDcxMDY4,size_16,color_FFFFFF,t_70