目录
一，引言
二，基本结构
三，hash迭代器
四，HashTable的基本结构
一，引言
在实现哈希表之后，在unordered_set和unordered_map的学习中。了解到这两者的数据结构底层是由哈希表实现的，为此在实现哈希表的基础上对哈希表进行封装。
二，基本结构
首先要需要对Node节点进行修改。此过程和红黑树的封装类似。由上层结构决定是set还是map：
参考代码如下：
template<class T> struct HashNode { T _data; HashNode<T>* _next; HashNode(const T& data) :_data(data) , _next(nullptr) {} };T的具体类型由上层传入进行决定。
KeyOFT仿函数以及hash仿函数
在上述节点的基本类型中为T类型，因此并不直到上层究竟是map还是set。为此第一个仿函数的作用是返回这两者的key值。
hash仿函数和哈希表的实现中作用一致，这里就不详细讲解。
三，hash迭代器
哈希表表支持的迭代器是单向迭代器，红黑树所支持的是双向迭代器。但是基础机构基本上相似，参考代码如下：
template<class K, class T, class Ptr, class Ref, class KeyOfT, class Hash> struct HTIterator { typedef HashNode<T> Node; typedef HTIterator<K, T, Ptr, Ref, KeyOfT, Hash> Self; Node* _node; const HashTable<K, T, KeyOfT, Hash>* _pht; HTIterator(Node* node, const HashTable<K, T, KeyOfT, Hash>* pht) :_node(node) , _pht(pht) {} };由于迭代器要实现++操作。哈希表内部是链式结构，在迭代器++的过程中，当该节点所链接的节点结束，则需要寻找下一个数组的节点。为此不仅需要node指针指向节点，还需要哈希表指针指向该哈希表。
在该迭代器的模板的第二，三，四个参数分别代表这数据（数据类型）（数据指针类型）（数据引用类型）。方便后续区分const迭代器。在迭代器内部封装的结构和红黑树相似。
operator*
Ref operator*() { return _node->_data; }operator->
Ptr operator->() { return &_node->_data; }operator!=
bool operator!=(const Self& s) { return _node != s._node; }operator++
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]) { break; } ++hashi; } if (hashi == _pht->_tables.size()) { _node = nullptr; // end() } else { _node = _pht->_tables[hashi]; } } return *this; }若该节点的下一个位置还有节点，则直接node++。若已经到这条链的最后一个节点。则重新确定这个节点的位置。找到下一个非空节点。返回这个位置的迭代器。
四，HashTable的基本结构
template<class K, class T, class KeyOfT, class Hash> class HashTable { // 友元声明 template<class K, class T, class Ptr, class Ref, 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> private: vector<Node*> _tables; // size_t _n = 0; // };这里需要注意类模板的友元声明。使得上文HTIterator能够访问HashTable的私有成员。
下面就是迭代器封装
Iterator Begin() { if (_n == 0) return End(); for (size_t i = 0; i < _tables.size(); i++) { Node* cur = _tables[i]; if (cur) { return Iterator(cur, this); } } return End(); } Iterator End() { return Iterator(nullptr, this); } ConstIterator Begin() const { if (_n == 0) return End(); for (size_t i = 0; i < _tables.size(); i++) { Node* cur = _tables[i]; if (cur) { return ConstIterator(cur, this); } } return End(); } ConstIterator End() const { return ConstIterator(nullptr, this); }Insert的修改
Insert修改和这个基本上都类似。
五，my_unordered_set封装
基本结构和红黑树相似，与红黑树不同的是这里需要提供上文中所将到的KeyOFT，来返回key的值，参考代码如下：
struct SetKeyOfT { const K& operator()(const K& key) { return key; } };基本结构如下：
template<class K, class Hash = HashFunc<K>> class unordered_set { struct SetKeyOfT { const K& operator()(const K& key) { return key; } }; public: typedef typename hash_bucket::HashTable<K, const K, SetKeyOfT, Hash>::Iterator iterator; typedef typename hash_bucket::HashTable<K, const K, SetKeyOfT, Hash>::ConstIterator const_iterator; private: hash_bucket::HashTable<K, const K, SetKeyOfT, Hash> _ht; };这里需要注意不能单单用typedef，而是要使用typedef typename来强调后者修饰的是类型，而不是变量。map和set基本上一致。