【C++—STL】哈希表底层封装与unorderedset/unorderedmap模拟实现

最新推荐文章于 2025-12-11 21:09:37 发布
原创 最新推荐文章于 2025-12-11 21:09:37 发布 · 834 阅读 · 10 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
文章标签：

#c++ #开发语言 #stl #数据结构 #哈希算法 #散列表

2025博客之星年度评选已开启 10w+人浏览 529人参与

目录

引言

一. 源码及框架分析

二. 模拟实现unorderedset/unorderedmap

2.1 实现出复用的哈希表

2.1.1 实现复用的哈希表的整体框架

2.1.2 实现KeyOfT仿函数

2.1.3 迭代器的实现

1）底层迭代器的实现

2）哈希表中封装迭代器

2.2 封装哈希表实现unorderedset

2.3 封装哈希表实现unorderedmap

2.3.1 实现operator[ ]

2.3.2 完整代码实现

结语

引言

        在C++标准模板库（STL）中，unordered_map和unordered_set是高效的无序关联容器，底层基于哈希表实现，提供平均O(1)时间复杂度的查找、插入和删除操作。这些容器在实际应用中广泛用于缓存、数据去重和快速查询场景。理解其内部机制有助于更好地优化代码和处理边缘情况。

一. 源码及框架分析

SGI-STL30版本源代码中没有unordered_map和unordered_set，SGI-STL30版本是C++11之前的STL 版本，这两个容器是C++11之后才更新的。但是SGI-STL30实现了哈希表，只容器的名字是hash_map和hash_set，他是作为非标准的容器出现的，非标准是指非C++标准规定必须实现的，源代码在 hash_map/hash_set/stl_hash_map/stl_hash_set/stl_hashtable.h中 hash_map和hash_set的实现结构框架核心部分截取出来如下：

// stl_hash_set
template <class Value, class HashFcn = hash<Value>,
class EqualKey = equal_to<Value>,
class Alloc = alloc>
class hash_set
{
private:
typedef hashtable<Value, Value, HashFcn, identity<Value>,
EqualKey, Alloc> ht;
ht rep;
public:
typedef typename ht::key_type key_type;
typedef typename ht::value_type value_type;
typedef typename ht::hasher hasher;
typedef typename ht::key_equal key_equal;
typedef typename ht::const_iterator iterator;
typedef typename ht::const_iterator const_iterator;
hasher hash_funct() const { return rep.hash_funct(); }
key_equal key_eq() const { return rep.key_eq(); }
};

// stl_hash_map
template <class Key, class T, class HashFcn = hash<Key>,
class EqualKey = equal_to<Key>,
class Alloc = alloc>
class hash_map
{
private:
typedef hashtable<pair<const Key, T>, Key, HashFcn,
select1st<pair<const Key, T> >, EqualKey, Alloc> ht;
ht rep;
public:
typedef typename ht::key_type key_type;
typedef T data_type;
typedef T mapped_type;
typedef typename ht::value_type value_type;
typedef typename ht::hasher hasher;
typedef typename ht::key_equal key_equal;
typedef typename ht::iterator iterator;
typedef typename ht::const_iterator const_iterator;
};

// stl_hashtable.h
template <class Value, class Key, class HashFcn,
class ExtractKey, class EqualKey,
class Alloc>
class hashtable {
public:
typedef Key key_type;
typedef Value value_type;
typedef HashFcn hasher;
typedef EqualKey key_equal;
private:
hasher hash;
key_equal equals;
ExtractKey get_key;
typedef __hashtable_node<Value> node;
vector<node*,Alloc> buckets;
size_type num_elements;
public:
typedef __hashtable_iterator<Value, Key, HashFcn, ExtractKey, EqualKey,
Alloc> iterator;
pair<iterator, bool> insert_unique(const value_type& obj);
const_iterator find(const key_type& key) const;
};
template <class Value>
struct __hashtable_node
{
__hashtable_node* next;
Value val;
};

通过源码可以看到，结构上hash_map和hash_set跟map和set的完全类似，复用同一个hashtable实现key和key/value结构，hash_set传给hash_table的是两个 key，hash_map传给hash_table的是pair<const key, value>

二. 模拟实现unorderedset/unorderedmap

2.1 实现出复用的哈希表

2.1.1 实现复用的哈希表的整体框架

和set/map类似，我们将哈希表中存储的节点类型定义为模板类型，set传递的模板参数是K，map传递的模板参数是pair<K,V>，这样，同一个哈希表就能实现复用

template<class T>
struct HashNode
{
	T _data;
	HashNode<T>* next;

	HashNode(const T& data)
		:_data(data)
		,next(nullptr)
	{}
};

2.1.2 实现KeyOfT仿函数

用上述方法修改之后，又会有一个新的问题，unordered_set中存储的是key，unordered_map中存储的是pair<K,V>，

为了让 unordered_map 和 unordered_set 复用代码，底层的 HashTable 必须足够通用。最大的难点在于：

  • Set 存储的是 Key。

  • Map 存储的是 pair<const Key, Value>。

  • 哈希表在计算哈希值、比较相等时，都需要获取 Key。对于 Set，数据本身就是 Key；对于 Map，需要从 Pair 中提取 Key。

为了解决上述差异，我们在 HashTable 的模板参数中引入了一个 KeyOfT 仿函数策略

template<class K, class T, class KeyOfT, class Hash>
class HashTable
{
    // ...
    // K: 键的类型
    // T: 存储的数据类型（Set是K，Map是pair<const K, V>）
    // KeyOfT: 从T中提取K的仿函数
};

这样，上层容器只需传入不同的仿函数：

  • unordered_set: 传入 SetKeyOfT，直接返回数据本身

  • unordered_map: 传入 MapKeyOfT，返回 pair<K,V>.first

template<class K, class Hash = HashFunc<K>>
class unordered_set
{
	// 内部类（把key取出来）
	struct SetKeyOfT
	{
		const K& operator()(const K& key)
		{
			return key;
		}
	};
}
template<class K, class V, class Hash = HashFunc<K>>
class unordered_map
{
	// 内部类（把key取出来）
	struct MapKeyOfT
	{
		const K& operator()(const pair<K, V>& kv)
		{
			return kv.first;
		}
	};
}

2.1.3 迭代器的实现

1）底层迭代器的实现

哈希表的迭代器是单向迭代器（Forward Iterator）。它的难点在于如何在“断开”的桶之间进行遍历(operator++)。迭代器不仅需要指向当前的节点 _node，还需要持有哈希表对象 _pht 的指针。这是因为当一个桶遍历完后，需要通过哈希表对象找到下一个非空桶 。

iterator实现思路分析：

  • iterator实现的大框架跟list的iterator思路是一致的，用一个类型封装结点的指针，再通过重载运算符实现，迭代器像指针一样访问的行为，要注意的是哈希表的迭代器是单向迭代器。
  • 这里的难点是operator++的实现。iterator中有一个指向结点的指针，如果当前桶下面还有结点， 则结点的指针指向下一个结点即可。如果当前桶走完了，则需要想办法计算找到下一个桶。这里的 难点是反而是结构设计的问题，参考上面的源码，我们可以看到iterator中除了有结点的指针，还 有哈希表对象的指针，这样当前桶走完了，要计算下一个桶就相对容易多了，用key值计算出当前桶位置，依次往后找下一个不为空的桶即可。
  • begin()返回第一个桶中第一个节点指针构造的迭代器，这里end()返回迭代器可以用空表示。
  • unordered_set的iterator不支持修改，我们把unordered_set的第二个模板参数改成const K即可， HashTable<K, const K, SetKeyOfT, Hash> _ht;
  • unordered_map的iterator不支持修改key但是可以修改value，我们把unordered_map的第二个模板参数pair的第一个参数改成const K即可， HashTable<K, pair<K,V>, MapKeyOfT, Hash> _ht;

operator++的逻辑：

  • 如果当前节点的 _next 不为空，直接指向下一个节点。

  • 如果当前桶已经走完（_next 为空），则需要计算当前 Key 的哈希值，找到当前桶的索引。

  • 从当前索引的下一个位置开始，线性探测 _tables，直到找到第一个非空桶，或者走完所有桶 

Self operator++()
{
	// 当前桶没走完
	if (_node->next)
	{
		_node = _node->next;
	}
	// 当前桶没走完，找到下一个桶的第一个节点（哈希表的指针就是在这里用的）
	else
	{
		KeyOfT kot;
		Hash hs;
		// 先算出当前在那个桶
		size_t hashi = hs(kot(_node->_data)) % _pht->_tables.size();
		// 要从当前桶的下一个桶开始找
		++hashi;
		while (hashi < _pht->_tables.size())
		{
			// 找到下一个不为空的桶
			if (_pht->_tables[hashi])
			{
				_node = _pht->_tables[hashi];
				break;
			}
			else
			{
				++hashi;
			}
		}

		// 最后一个桶走完了，要++到end()迭代器位置
		if (hashi == _pht->_tables.size())
		{
			// end()中的_node是空
			_node = nullptr;
		}
	}

	return *this;
}

这里只实现了比较复杂的operator++()，完整代码详见：底层迭代器的实现

2）哈希表中封装迭代器
template<class K, class T, class KeyOfT, class Hash>
class HashTable
{
	// 友元声明：类模板当友元，要加上模板参数
	// 让迭代器成为哈希表的友元，因为在迭代器中会访问哈希表的私有成员变量_tables；另一种方法是写GetTable函数
	template<class K, class T, class Ref, class Ptr, class KeyOfT, class Hash>
	friend struct HtIterator;

	typedef HashNode<T> Node;
public:
	typedef HtIterator<K, T, T&, T*, KeyOfT, Hash> Iterator;
	typedef HtIterator<K, T, const T&, const T*, KeyOfT, Hash> ConstIterator;

	Iterator Begin()
	{
		// 找到第一个不为空的桶
		for (size_t i = 0; i < _tables.size(); i++)
		{
			// 如果没有数据就直接return End()，不用再遍历了
			if (_n == 0)
			{
				return End();
			}

			if (_tables[i])
			{
				// 用节点的指针和哈希表的指针构造；this就是哈希表的指针
				return Iterator(_tables[i], this);
			}
		}

		// 没有找到
		return End();
	}

	Iterator End()
	{
		return Iterator(nullptr, this);
	}

	ConstIterator Begin() const
	{
		// 找到第一个不为空的桶
		for (size_t i = 0; i < _tables.size(); i++)
		{
			// 如果没有数据就直接return End()，不用再遍历了
			if (_n == 0)
			{
				return End();
			}

			if (_tables[i])
			{
				// 用节点的指针和哈希表的指针构造；this就是哈希表的指针
				return ConstIterator(_tables[i], this); // 这里的this类型是const HT*，所以HtIterator的构造函数中，哈希表的指针要const
			}
		}

		// 没有找到
		return End();
	}

	ConstIterator End() const
	{
		return ConstIterator(nullptr, this); // 这里的this类型是const HT*，所以HtIterator的构造函数中，哈希表的指针要const
	}
}

2.2 封装哈希表实现unorderedset

unordered_set 的核心是将 Key 既作为 Key 也作为 Value。需要注意的是，Set 中的元素是不可修改的，因此我们传递给 HashTable 的模板参数是 const K 。

2.3 封装哈希表实现unorderedmap

unordered_map 存储的是键值对。

  • 数据类型：pair<const K, V>（Key不可改，Value可改）。

  • Key提取：使用 MapKeyOfT 返回 kv.first 。

2.3.1 实现operator[ ]

unordered_map 的 [] 运算符非常强大：如果 Key 存在则返回 Value 的引用，不存在则插入默认值并返回引用。这依赖于底层的 Insert 函数返回类型 pair<iterator, bool>

V& operator[](const K& key) {
    // 尝试插入 {key, 默认值}
    pair<iterator, bool> ret = _ht.Insert(make_pair(key, V()));
    // 无论插入成功还是失败，ret.first 都指向该 Key 所在的节点
    return ret.first->second;
}

2.3.2 完整代码实现

#include"HashTable.h"

namespace My
{
	// 这里的仿函数要放在上层，否则传仿函数传不过去
	// 其实还应该加一个和key比较相等的仿函数，这里没加
	template<class K, class V, class Hash = HashFunc<K>>
	class unordered_map
	{
		// 内部类（把key取出来）
		struct MapKeyOfT
		{
			const K& operator()(const pair<K, V>& kv)
			{
				return kv.first;
			}
		};

	public:
		typedef typename hash_bucket::HashTable<K, pair<const K, V>, MapKeyOfT, Hash>::Iterator iterator;
		typedef typename hash_bucket::HashTable<K, pair<const K, V>, MapKeyOfT, Hash>::ConstIterator const_iterator;

		iterator begin()
		{
			return _ht.Begin();
		}

		iterator end()
		{
			return _ht.End();
		}

		const_iterator begin() const
		{
			return _ht.Begin();
		}

		const_iterator end() const
		{
			return _ht.End();
		}

		pair<iterator, bool> insert(const pair<K,V>& kv)
		{
			return _ht.Insert(kv);
		}

		V& operator[](const K& key)
		{
			pair<iterator, bool> ret = insert({ key,V() });
			return ret.first->second;
		}

		iterator find(const K& key)
		{
			return _ht.Find(key);
		}

		bool erase(const K& key)
		{
			return _ht.Erase(key);
		}

	private:
		hash_bucket::HashTable<K, pair<const K, V>, MapKeyOfT, Hash> _ht;
	};
}

结语

如有不足或改进之处，欢迎大家在评论区积极讨论，后续我也会持续更新C++相关的知识。文章制作不易，如果文章对你有帮助，就点赞收藏关注支持一下作者吧，让我们一起努力，共同进步！

C++STL详解(十) -- 使用哈希表封装unordered_set和unordered_map
清欢Allen的技术博客
04-25 1047
(1):set模板参数要求能够支持小于比较,例如:二叉搜索树查找成员函数中,我们可以利用compare仿函数将当前结点值与所给值比较,从而决定cur遍历左子树还是右子树,为了能够支持大于比较的,我们可以交换一下实参位置,这也间接支持了大于比较.并且条件判断,进而也支持了等于.(1)针对于K类型(指针,打浮点数,有符号整型)可以转换为无符号整数取模.对于string,日期类类型,这两个类型与整型类型无关的,此时不可以直接强转为整数,需要相应的提供将该类型转换为整数的仿函数.
【C++】哈希表封装unordered_set和unordered_map
春风不语。
11-19 1856
本篇到这里就结束了，主要讲了用哈希表封装unordered_set和unordered_map的详细过程，希望对大家有帮助，祝生活愉快！
【C++】哈希表封装实现 unordered_map 和 unordered_set
2401_86785052的博客
10-31 1018
本期博客讲解了使用一套哈希表代码封装实现 unordered_set 和 unordered_map，逐步带你掌握封装技巧
C++ STL之哈希封装实现unordered_map/set
2301_79976271的博客
08-31 496
基本框架仿照封装红黑树实现map/set，对HashTable进行了修改，依旧沿用之前的泛型思想，并且详细讲解了HashTable的迭代器
C++ 用哈希表封装unordered_set/unordered_map
2401_84771520的博客
04-19 1264
本篇文章我们将使用哈希表来封装unordered_set/unordered_map。但是大家要注意，在实现前一定要先保证自己的哈希表是能跑才可以来封装，而且我们的哈希表解决冲突的方式是哈希桶，并不是线性探测法。！！
c++STL——哈希表封装：实现高效unordered_map与unordered_set
2301_79705195的博客
05-14 870
本文介绍了如何使用哈希表封装C++中的unordered_map和unordered_set容器。首先，文章回顾了哈希表的实现原理，并指出C++标准库中的这两个容器底层也是基于哈希桶实现的。接着，文章详细讨论了如何改进哈希表的底层框架，特别是通过泛化数据类型和使用模板参数KeyOfT来提取关键字，从而支持unordered_map和unordered_set的封装。 文章还探讨了哈希表迭代器的实现，指出哈希桶的迭代器是单向的，因为哈希桶底层使用的是单链表。迭代器的实现需要包含指向节点的指针和指向哈希表的指
【C++ STL】哈希表封装unordered_set和unordered_map
2403_88316985的博客
09-03 877
基于链地址法的哈希表实现，重点分析了unordered_set和unordered_map的底层结构设计。主要内容包括： 哈希表结构分析：通过模板参数区分键值类型、存储类型、哈希函数和键值提取方法，使用vector<Node*>实现链地址法。 迭代器设计：哈希表迭代器为单向迭代器，通过维护指向哈希表的指针实现跨桶遍历，支持operator++操作。 元素操作：详细说明了insert方法的实现，返回包含迭代器和插入结果的pair类型，确保能正确反馈插入状态。 文章还提供了哈希表的基本框架。
C++——STL——unordered_map与unordered_set的使用以及使用哈希表封装unordered_map/set
2402_86667364的博客
05-26 1000
1.unordered_set的声明如上，Key就是unordered_set底层关键字的类型默认要求Key支持转换为整形，如果不支持或者想按自己的需求走可以自行实现支 持将Key转成整形的仿函数传给第二个模板参数t默认要求Key支持比较相等，如果不支持或者想按自己的需求走可以自行实现支持 将Key比较相等的仿函数传给第三个模板参数底层存储数据的内存是从空间配置器申请的，如果需要可以自己实现内存池，传给 第四个参数。5.⼀般情况下，我们都不需要传后三个模板参数。
【C++ STL】unordered_map&unordered_set (哈希表）
Z1tai的博客
08-08 1420
哈希也叫做散列，记数排序就体现了哈希思想。计数排序为统计数字出现的个数，为每个数字都开辟了对应的一块空间，用来记录其出现的个数，每遇到就加一。将一个元素和一个位置建立映射关系，这就是哈希的本质。常见的数据类型如整数，库中自带哈希函数，但有些类型比如自定义类型，需要我们自定义哈希函数。可以把哈希函数设计成仿函数，对不同类型添加特化处理。return key;// 特化template<>//BKDRreturn val;
【C++ STL】模拟实现 unordered_set/map 系列容器（对一张哈希表进行封装）
codewinter的博客
07-01 931
unordered 系列容器（unordered_map / unordered_set …），其底层封装了一张哈希表（开散列、哈希桶），重点在于哈希表的结构以及相关的接口的实现。哈希表（哈希桶）的结构：这里直接拿我们自己写的开散列（原先是KV模型的）改造下，使其既可兼容K模型，也可兼容KV模型：哈希表里面具体存的是什么类型的元素，是由模板参数 T 来决定：哈希表节点结构： 1.2 定义哈希表的迭代器 迭代器的结构：👉注意：哈希表迭代器封装的是「节点指针」和「哈希表指针」，因为要在哈希表中找下一个桶，所.
哈希表封装实现unordered_set unordered_map
moringlightyn的博客
10-05 637
先来分析一下 ++应该是要到下一个节点的位置 如果当前哈希桶的下一个位置还有值的话即当前节点的next指针不为空 下一个节点就应该到next指针指向的位置 如果下一个位置为空即next指针为空了说明当前的哈希桶已经走完了 此时++应该是到下一个不为空的哈希桶的头节点。迭代器打印的方式 范围for打印的方式及const类型对象的打印都可以了( 第三个打印调用的print函数 里面的形参是const类型 里面的范围for会调用const类型的迭代器)
C++ 使用哈希表封装模拟实现unordered_map unordered_set
TPON的博客
11-17 1044
C++实现哈希表封装unordered_map unordered_set
【C++】开散列哈希表封装实现unordered_map和unordered_set
The porters of knowledge
04-05 992
unordered系列关联式容器，哈希冲突和哈希函数，闭散列和开散列哈希表的实现，用闭散列哈希表封装实现unordered_set和map，封装实现时哈希表特殊的const迭代器……
侯捷C++ STL：哈希表（unordered_set,unordered_multiset,unordered_map,unordered_multimap）的底层实现
weixin_39770712的博客
11-09 1065
哈希表的产生由于内存不够一一映射。于是乎在空间不足时取余数。 为了防止某一个链表过长，这里根据经验来制定规则。当插入的元素个数等于buckets时这时哈希表要扩容。扩容因子是两倍。但是buckets值尽量是质数，选择质数是为了尽量做到均匀散列。所以扩容后要找两倍大后附近的质数。编译器将空间扩容的空间大小都自己定义好了，不用重新计算空间，53-97-193…。 底层实现： HashFcn：一个对象如何映射为一个号码/编号。hasher,key_equal,ExtractKey是function objec
C语言实战
2201_75969037的博客
12-11 116
摘要：本文总结了C语言在实战开发中的核心应用场景，包括基础数据类型操作、内存管理、文件处理等基础内容，以及数据结构实现、算法编写、多线程编程和网络通信等进阶应用。重点展示了变量声明、动态内存分配、文件读写、链表实现、快速排序等典型代码示例，同时介绍了POSIX线程创建和TCP网络编程方法，最后提供了gdb调试和循环展开优化等实用技巧。
【MCAL】CCFC3008PC-EB配置之SPI
wwjh_go的博客
12-11 436
摘要：本文介绍了DSPI(反序列化串行外设接口)的配置与应用。系统包含7个DSPI模块，实际使用了DSPI1和DSPI2两个模块。重点阐述了SPI通信的基本单元结构：Job(完整通信)、Channel(数据装载)和Sequence(操作序列)的关系。详细说明了SPI的配置流程，包括通道、任务、序列、硬件和外设等设置。最后通过工程测试验证了SPI通信功能，展示了片选信号、时钟信号以及MOSI/MISO数据线的波形图。测试结果表明系统实现了预期的SPI数据传输功能。
C++ 日志实现
weixin_42252757的博客
12-11 100
【代码】C++ 日志实现。
C语言一维数组完全指南：从基础到实战应用
最新发布
Herbert_hwt的博客
12-11 205
在C语言编程中，数组是一种非常重要的数据结构，而一维数组是最基础且最常用的形式。数组是相同类型元素的集合，这些元素在内存中连续存放，通过统一的数组名和下标来访问各个元素。// 等价于 {1, 2, 3, 0, 0}i++) { // 正确：i < 5。
C++ 高性能编程要点
2502_90907501的博客
12-07 355
本文介绍了C++性能优化的关键技术：1）内存管理方面建议使用智能指针、对象池和自定义分配器；2）算法选择强调连续内存容器和复杂度匹配；3）编译器优化包括内联、PGO和编译时计算；4）硬件层面利用SIMD指令、缓存预取和任务并行。文中提供了SIMD浮点求和和无锁队列的代码示例，展示了如何通过底层优化显著提升性能。这些方法覆盖了从内存管理到硬件特性的多级优化策略。
评论
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
红包 添加红包
表情包 插入表情
表情包 代码片
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值