当前位置： 首页 > news >正文

C++：用哈希表封装unordered_map，unordered_set（代码版）

news 2025/11/5 15:21:34

        可以先看一下这篇哈希表的模拟实现：

C++：哈希表的实现-CSDN博客

一、SGI-STL30版本中的源码

        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>

二、模拟实现

        与map和set相比而言 unordered_map和unordered_set的模拟实现类结构更复杂一点，但是 大框架和思路是完全类似的。因为HashTable实现了泛型不知道T参数传的是K，还是pair， 那么insert内部进行插入时要用 K 对象转换成整形取模 和 K 比较相等，因为pair的value不参与计算取 模，且默认支持的是key和value一起比较相等，我们需要时的任何时候只需要比较 K 对象，所以在unordered_map和unordered_set层分别实现一个MapKeyOfT和SetKeyOfT的仿函数传给 HashTable的KeyOfT，然后HashTable中通过KeyOfT仿函数取出T类型对象中的K对象，再转换成 整形取模和K比较相等。

1、基本框架

// Unordered_Map.h
#pragma once#include"HashTable.h"namespace mystl
{template<class K, class V>class unordered_map{struct MapKeyOfT{const K& operator()(const pair<K, V>& kv){return kv.first;}};public:bool insert(const pair<K, V>& kv){return _t.Insert(kv);}private:HashTable<K, pair<K, V>, MapKeyOfT> _t;};void test_umap(){unordered_map<string, string> dict;dict.insert({ "insert", "" });dict.insert({ "sort", "" });dict.insert({ "test", "" });/*for (auto& [k, v] : dict){cout << k << ":" << v << endl;}*/}
};
// Unordered_Set.h#pragma once#include"HashTable.h"namespace mystl
{template<class K>class unordered_set{struct SetKeyOfT{const K& operator()(const K& key){return key;}};public:bool insert(const K& k){return _t.Insert(k);}private:HashTable<K, K, SetKeyOfT> _t;};void test_uset(){unordered_set<int> s1;s1.insert(45);s1.insert(5);s1.insert(13);s1.insert(45);/*auto it1 = s1.begin();while (it1 != s1.end()){cout << *it1 << " ";++it1;}cout << endl;*/}
};
// HashTable.h
#pragma once
#include<vector>
#include <string>
using namespace std;template<class K>
struct HashFunc
{size_t operator()(const K& key){return (size_t)key;}
};
template<>
struct HashFunc<string>
{// BKDRsize_t operator()(const string& str){size_t hash = 0;for (auto ch : str){hash += ch;hash *= 131;}return hash;}
};
inline unsigned long __stl_next_prime(unsigned long n)
{// Note: assumes long is at least 32 bits.static const int __stl_num_primes = 28;static const unsigned long __stl_prime_list[__stl_num_primes] ={53, 97, 193, 389, 769,1543, 3079, 6151, 12289, 24593,49157, 98317, 196613, 393241, 786433,1572869, 3145739, 6291469, 12582917, 25165843,50331653, 100663319, 201326611, 402653189, 805306457,1610612741, 3221225473, 4294967291};const unsigned long* first = __stl_prime_list;const unsigned long* last = __stl_prime_list + __stl_num_primes;const unsigned long* pos = lower_bound(first, last, n);return pos == last ? *(last - 1) : *pos;
}template<class T>
struct HashNode
{T _data;HashNode<T>* _next;HashNode(const T& data):_data(data),_next(nullptr){ }
};template<class K, class T, class KeyofT, class Hash = HashFunc<K>> 
class HashTable
{typedef HashNode<T> Node;
public:HashTable():_tables(__stl_next_prime(1), nullptr), _n(0){ }~HashTable(){for (size_t i = 0; i < _tables.size(); i++){Node* cur = _tables[i];while (cur){Node* next = cur->_next;delete cur;cur = next;}_tables[i] = nullptr;}}bool Insert(const T& data){KeyofT kot;if (Find(kot(data)))return false;Hash hs;// 负载因子==1扩容if (_n == _tables.size()){//HashTable<K, V> newHT;//newHT._tables.resize(_tables.size()*2);//// 遍历旧表将所有值映射到新表//for (auto cur : _tables)//{//	while (cur)//	{//		newHT.Insert(cur->_kv);//		cur = cur->_next;//	}//}//_tables.swap(newHT._tables);vector<Node*> newtables(__stl_next_prime(_tables.size() + 1));for (size_t i = 0; i < _tables.size(); i++){Node* cur = _tables[i];// 当前桶的节点重新映射挂到新表while (cur){Node* next = cur->_next;// 插入到新表size_t hashi = hs(kot(cur->_data)) % newtables.size();cur->_next = newtables[hashi];newtables[hashi] = cur;cur = next;}_tables[i] = nullptr;}_tables.swap(newtables);}size_t hashi = hs(kot(data)) % _tables.size();// 头插Node* newNode = new Node(data);newNode->_next = _tables[hashi];_tables[hashi] = newNode;++_n;return true;}Node* Find(const K& key){Hash hs;KeyofT kot;size_t hashi = hs(key) % _tables.size();Node* cur = _tables[hashi];while (cur){if (kot(cur->_data) == key)return cur;cur = cur->_next;}return nullptr;}bool Erase(const K& key){Hash hs;KeyofT kot;size_t hashi = hs(key) % _tables.size();Node* prev = nullptr;Node* cur = _tables[hashi];while (cur){if (kot(cur->_data) == key){if (prev == nullptr){_tables[hashi] = cur->_next;}else{prev->_next = cur->_next;}delete cur;return true;}prev = cur;cur = cur->_next;}return false;}private://vector<list<pair<K, V>>> _tables;vector<Node*> _tables;size_t _n = 0;  // 实际存储的数据个数
};

2、迭代器的实现

2.1框架

// 前置声明
template<class K, class T, class KeyOfT, class Hash>
class HashTable;template<class K, class T, class KeyOfT, class Hash>
struct HTIterator
{typedef HashNode<T> Node;typedef HashTable<K, T, KeyOfT, Hash> HT;typedef HTIterator<K, T, KeyOfT, Hash> Self;Node* _node;const HT* _ht;HTIterator(Node* node, const HT* ht):_node(node), _ht(ht){}T& operator*(){return _node->_data;}T* operator->(){return &_node->_data;}Self& operator++(){if (_node->_next)  // 当前还有节点{_node = _node->_next;}else  // 当前桶为空，找下一个不为空的桶的第一个{size_t hashi = Hash()(KeyOfT()(_node->_data)) % _ht->_tables.size();++hashi;while (hashi != _ht->_tables.size()){if (_ht->_tables[hashi]){_node = _ht->_tables[hashi];break;}hashi++;}// 最后一个桶的最后一个节点已经遍历结束，走到end()去，nullptr充当end()if (hashi == _ht->_tables.size()){_node = nullptr;}}return *this;}bool operator!=(const Self& s) const{return _node != s._node;}bool operator==(const Self& s) const{return _node == s._node;}
};

2.2实现const修饰


// 前置声明
template<class K, class T, class KeyOfT, class Hash>
class HashTable;template<class K, class T, class Ref, class Ptr, class KeyOfT, class Hash>
struct HTIterator
{typedef HashNode<T> Node;typedef HashTable<K, T, KeyOfT, Hash> HT;typedef HTIterator<K, T, Ref, Ptr, KeyOfT, Hash> Self;Node* _node;const HT* _ht;HTIterator(Node* node, const HT* ht):_node(node), _ht(ht){}Ref operator*(){return _node->_data;}Ptr operator->(){return &_node->_data;}Self& operator++(){if (_node->_next)  // 当前还有节点{_node = _node->_next;}else  // 当前桶为空，找下一个不为空的桶的第一个{size_t hashi = Hash()(KeyOfT()(_node->_data)) % _ht->_tables.size();++hashi;while (hashi != _ht->_tables.size()){if (_ht->_tables[hashi]){_node = _ht->_tables[hashi];break;}hashi++;}// 最后一个桶的最后一个节点已经遍历结束，走到end()去，nullptr充当end()if (hashi == _ht->_tables.size()){_node = nullptr;}}return *this;}bool operator!=(const Self& s) const{return _node != s._node;}bool operator==(const Self& s) const{return _node == s._node;}
};

3.对于unordered_map，和unordered_set的实现，看下面的代码

        在封装const_iterator的时候，注意const this指针，需要把ht也用const修饰一下，否则涉及权限放大的问题。这个编译报错很难看出来。

三、所有代码

// unordered_map.h
#pragma once#include"HashTable.h"namespace mystl
{template<class K, class V, class Hash = HashFunc<K>>class unordered_map{struct MapKeyOfT{const K& operator()(const pair<K, V>& kv){return kv.first;}};public:typedef typename HashTable<K, pair<const K, V>, MapKeyOfT, Hash>::Iterator iterator;typedef typename HashTable<K, pair<const K, V>, MapKeyOfT, Hash>::ConstIterator const_iterator;iterator begin(){return _t.Begin();}iterator end(){return _t.End();}const_iterator begin() const{return _t.Begin();}const_iterator end() const{return _t.End();}pair<iterator, bool> insert(const pair<K, V>& kv){return _t.Insert(kv);}V& operator[](const K& key){pair<iterator, bool> ret = insert({ key, V() });return ret.first->second;}bool erase(const K& key){return _t.Erase(key);}iterator find(const K& key){return _t.Find(key);}private:HashTable<K, pair<const K, V>, MapKeyOfT, Hash> _t;};
};
// Unordered_Set.h
#pragma once#include"HashTable.h"namespace mystl
{template<class K, class Hash = HashFunc<K>>class unordered_set{struct SetKeyOfT{const K& operator()(const K& key){return key;}};public:typedef typename HashTable<K, const K, SetKeyOfT, Hash>::Iterator iterator;typedef typename HashTable<K, const K, SetKeyOfT, Hash>::ConstIterator const_iterator;iterator begin(){return _t.Begin();}iterator end(){return _t.End();}const_iterator begin() const{return _t.Begin();}const_iterator end() const{return _t.End();}pair<iterator, bool> insert(const K& k){return _t.Insert(k);}bool erase(const K& key){return _t.Erase(key);}iterator find(const K& key){return _t.Find(key);}private:HashTable<K, const K, SetKeyOfT, Hash> _t;};
};

// HashTable.h
#pragma once
#include<vector>template<class K>
struct HashFunc
{size_t operator()(const K& key){return (size_t)key;}
};template<>
struct HashFunc<string>
{// BKDRsize_t operator()(const string& str){size_t hash = 0;for (auto ch : str){hash += ch;hash *= 131;}return hash;}
};inline unsigned long __stl_next_prime(unsigned long n)
{// Note: assumes long is at least 32 bits.static const int __stl_num_primes = 28;static const unsigned long __stl_prime_list[__stl_num_primes] ={53, 97, 193, 389, 769,1543, 3079, 6151, 12289, 24593,49157, 98317, 196613, 393241, 786433,1572869, 3145739, 6291469, 12582917, 25165843,50331653, 100663319, 201326611, 402653189, 805306457,1610612741, 3221225473, 4294967291};const unsigned long* first = __stl_prime_list;const unsigned long* last = __stl_prime_list + __stl_num_primes;const unsigned long* pos = lower_bound(first, last, n);return pos == last ? *(last - 1) : *pos;
}template<class T>
struct HashNode
{T _data;HashNode<T>* _next;HashNode(const T& data):_data(data), _next(nullptr){}
};// 前置声明
template<class K, class T, class KeyOfT, class Hash>
class HashTable;template<class K, class T, class Ref, class Ptr, class KeyOfT, class Hash>
struct HTIterator
{typedef HashNode<T> Node;typedef HashTable<K, T, KeyOfT, Hash> HT;typedef HTIterator<K, T, Ref, Ptr, KeyOfT, Hash> Self;Node* _node;const HT* _ht;HTIterator(Node* node, const HT* ht):_node(node), _ht(ht){}Ref operator*(){return _node->_data;}Ptr operator->(){return &_node->_data;}Self& operator++(){if (_node->_next)  // 当前还有节点{_node = _node->_next;}else  // 当前桶为空，找下一个不为空的桶的第一个{size_t hashi = Hash()(KeyOfT()(_node->_data)) % _ht->_tables.size();++hashi;while (hashi != _ht->_tables.size()){if (_ht->_tables[hashi]){_node = _ht->_tables[hashi];break;}hashi++;}// 最后一个桶的最后一个节点已经遍历结束，走到end()去，nullptr充当end()if (hashi == _ht->_tables.size()){_node = nullptr;}}return *this;}bool operator!=(const Self& s) const{return _node != s._node;}bool operator==(const Self& s) const{return _node == s._node;}
};template<class K, class T, class KeyOfT, class Hash>
class HashTable
{// 友元声明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++){if (_tables[i]){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++){if (_tables[i]){return ConstIterator(_tables[i], this);}}return End();}ConstIterator End() const{return ConstIterator(nullptr, this);}HashTable():_tables(__stl_next_prime(1), nullptr), _n(0){}~HashTable(){for (size_t i = 0; i < _tables.size(); i++){Node* cur = _tables[i];// 当前桶的节点重新映射挂到新表while (cur){Node* next = cur->_next;delete cur;cur = next;}_tables[i] = nullptr;}}pair<Iterator, bool> Insert(const T& data){KeyOfT kot;auto it = Find(kot(data));if (it != End())return { it, false };Hash hs;// 负载因子==1扩容if (_n == _tables.size()){//HashTable<K, V> newHT;//newHT._tables.resize(_tables.size()*2);//// 遍历旧表将所有值映射到新表//for (auto cur : _tables)//{//	while (cur)//	{//		newHT.Insert(cur->_kv);//		cur = cur->_next;//	}//}//_tables.swap(newHT._tables);vector<Node*> newtables(__stl_next_prime(_tables.size() + 1));for (size_t i = 0; i < _tables.size(); i++){Node* cur = _tables[i];// 当前桶的节点重新映射挂到新表while (cur){Node* next = cur->_next;// 插入到新表size_t hashi = hs(kot(cur->_data)) % newtables.size();cur->_next = newtables[hashi];newtables[hashi] = cur;cur = next;}_tables[i] = nullptr;}_tables.swap(newtables);}size_t hashi = hs(kot(data)) % _tables.size();// 头插Node* newNode = new Node(data);newNode->_next = _tables[hashi];_tables[hashi] = newNode;++_n;return { Iterator(newNode, this), true };}Iterator Find(const K& key){KeyOfT kot;Hash hs;size_t hashi = hs(key) % _tables.size();Node* cur = _tables[hashi];while (cur){if (kot(cur->_data) == key)return { cur, this };cur = cur->_next;}return End();}bool Erase(const K& key){KeyOfT kot;Hash hs;size_t hashi = hs(key) % _tables.size();Node* prev = nullptr;Node* cur = _tables[hashi];while (cur){if (kot(cur->_data) == key){if (prev == nullptr){_tables[hashi] = cur->_next;}else{prev->_next = cur->_next;}delete cur;return true;}prev = cur;cur = cur->_next;}return false;}private://vector<list<pair<K, V>>> _tables;vector<Node*> _tables;size_t _n = 0;  // 实际存储的数据个数
};

http://www.dtcms.com/a/570610.html

相关文章：

  • 安徽建设工程信息网站做地方网站数据哪里来
  • 门户网站开发请示50个单页面网站设计欣赏(2)
  • 代码随想录训练营打卡Day36｜ 动态规划part04
  • HTB-Alert靶场 | 低难度Linux提权实战：漏洞链利用（XSS→文件读取→定时任务）详解
  • 我想做个网站推广怎么做网页制作与设计考的在哪查房
  • o2o商城网站建设方案怎么建网站
  • 从0开始学算法——第一天（认识算法）
  • 节点小宝4.0相册备份功能升级：技术优化与用户体验提升
  • 福州网站建设询q479185700上快成都大型网站建设公司排名
  • 第22课：行业实战：构建高质量技术文档智能支持系统
  • 网站关闭与域名备案app下载官网入口
  • 湛江网站建设方案外包1+手机官网首页
  • 4、foc控制系统——统一架构设计
  • QuickEsView
  • 积极做好门户网站建设工作住房城乡建设部举报网站
  • 企业网站会涉及到的版权问题网络服务投诉
  • AI 重塑招聘格局，传统招聘模式面临转型挑战
  • 网站帮助文档怎么写省财政厅门户网站三基建设
  • 无棣住房建设局网站wordpress域名授权破解版
  • 网站内页网页网站原型图占位符怎么做
  • 08-ubuntu如何获取发行版代号
  • navicat创建索引-mysql
  • 合肥做网站一般多少钱flash怎么做网页
  • 网站制作是不是要先用ps做中国企业网络营销现状
  • 英文网站建设成都eclipse做企业网站
  • rest参数和spread扩展运算符
  • 中国建站公司在线答题网站开发
  • Dinomaly2：最新多类无监督异常检测SOTA
  • 自己做片头的网站青岛网站建设外贸
  • DWG格式Web发布与GIS应用难题破解：奥维 VS GISBox