正文开始前给大家推荐个网站，前些天发现了一个巨牛的人工智能学习网站，通俗易懂，风趣幽默，忍不住分享一下给大家。点击跳转到网站。

unordered_map是存的是pair是K，V型的，而unordered_set是K型的，里面只存一个值，那我们如何利用一个数据结构将他们都封装出来呢？

我们知道哈希表我们实现的是存pair的，我们可以使用最笨的方法直接复制一份，把存pair的改为存Key的，但是我们可以参考一下大佬的做法，大佬直接把存的东西弄成一个模版参数，这个东西具体存的啥由用户来决定，用户传什么就存什么，所以改造后的哈希表的第二个类型模版参数就是我们要存的类型！

template <class T>
struct HashNode
{T _data;HashNode* _next;HashNode(const T& data): _data(data), _next(nullptr){}
};
template <class K, class V,class KeyOfT, class Hash = HashFunc<K>>
class HashTable
{typedef HashNode<V> Node;
private:KeyOfT kt;vector<Node*> _tables;size_t _n = 0;Hash hs;
};

我们可以看到V是什么类型，那么这个哈希表中存的就是什么，但是会有下一个问题，我们在取余时，不管是unordered_map还是unordered_set都是对Key取余，但是这里我们不知道他是Key还是pair，那怎么办呢？

我们可以通过仿函数解决这个问题，我们每个需要用Key计算的地方都走一层仿函数，然后unordered_set的就直接返回key就行，unordered_map则需要返回pair的first。我们会看到上面的结果多了个KeyOfT的模版，这个就是返回Key的仿函数。

unordered_map

template<class K, class V>
class unordered_map
{struct MapKOfT{const K& operator()(const pair<const K, V>& kv){return kv.first;}};private:hash_bucket::HashTable<K, pair<K,V>,MapKOfT> _ht;
};

unordered_set

template<class K>
class unordered_set
{struct SetKOfT{const K& operator()(const K& key){return key;}};private:hash_bucket::HashTable<K, K,SetKOfT> _ht;
};

至此我们最简单的框架就搭建出来了。需要注意的是所有需要用Key的地方都要走一层仿函数。
插入删除什么的直接复用哈希表的就可以，就下来主要就是实现迭代器。

迭代器

迭代器的结构应该是什么样子的？
节点的指针肯定是必须的，但是如果我们当前的桶走完了，如何++到下一个桶呢？
所以我们需要这张哈希表，用来找当前桶走完以后的下一个桶。这里不传这张哈希表也是可以的，因为我们的目的是找下一个桶，所以把哈希表中的vector传过来也是可以的。

那么迭代器如何++呢？

如果他的下一个节点是空，那么就说明这个桶走完了，我们需要找下一个桶，所以我们需要当前的位置，所以我们可以直接把当前桶的位置传过来，也可以当场计算桶的位置，这两种方法都是可以的，但是如果这张表走完了还没找到下一个桶，那就说明这张表走完了，我们直接把节点的指针改为nullptr即可。
如果它的下一个节点不为空，那直接让它等于它的next即可。

const的迭代器我们可以和之前一样，直接用两个模版参数来决定它是普通迭代器还是const迭代器。

template <class K, class V,class Ref, class Ptr, class KeyOfT, class Hash = HashFunc<K>>
struct __HTIterator
{typedef HashNode<V> Node;typedef __HTIterator<K, V,Ref,Ptr, KeyOfT, Hash> Self;Node* _node;const HashTable<K, V, KeyOfT, Hash>* _pht;size_t hashi;__HTIterator(Node* node,const HashTable<K, V, KeyOfT, Hash>* pht,size_t i): _node(node), _pht(pht), hashi(i){}Self operator++(){if (_node->_next){_node = _node->_next;}else{++hashi;while (hashi < _pht->_tables.size()){if (_pht->_tables[hashi]){_node = _pht->_tables[hashi];break;}++hashi;}if (hashi == _pht->_tables.size()){_node = nullptr;}}return *this;}bool operator!= (const Self& s){return _node != s._node;}bool operator== (const Self& s){return _node == s._node;}Ref operator*(){return _node->_data;}Ptr operator->(){return &(_node->_data);}
};

但是这里会有一个相互依赖的问题，就是哈希表需要用迭代器，迭代器需要用哈希表，如果哈希表在前面我们就需要前置声明一下迭代器，迭代器同理，我们需要在前面声明一个哈希表，但是解决完这个问题以后还存在一个问题，就是哈希表中的vector是私有成员，迭代器不能直接访问，所以我们需要把迭代器声明为哈希表的友元。

把迭代器实现好以后，接下来就是解决Key不能修改的问题。
unordeted_set和unordeted_map如何实现Key不能修改呢？
我们通过观察原码会发现unordeted_set迭代器和const迭代器都是const迭代器，它是通过这样的方式来实现的。unordeted_map是Key不能修改而Value是可以修改的，所以它的pair是pair<const K,V>它把Key设置为const，这样就能够保证Key不能修改，Value可以修改。

接下来需要实现的是unordered_map的[]重载，要实现这个重载我们就需要对哈希表的插入进行修改，它的返回值不能再是一个bool值，而是一个pair，这个pair的first是iterator迭代器，second是bool类型代表是否插入成功。改造完以后，就可以实现[]重载，但是对应容器的插入的返回值也需要变一下，[]重载主要就是存在就插入不存在就不插入，但是都会返回Val的是可以别被我们修改。

当改造完插入以后，我们会发现unordered_set的插入编译编不过，这是因为unordered_set的迭代器都是const迭代器，而哈希表的插入返回的是普通的迭代器，这里的iterator无法转化为const_iterator，所以编译错误，有两种方式可以解决，我们可以支持const迭代器转化为普通迭代器，我们也可以直接用const中的东西来构造新的普通迭代器。此时我们的封装差不多就完善了。

改造后的哈希表

namespace hash_bucket
{template <class T>struct HashNode{T _data;HashNode* _next;HashNode(const T& data): _data(data), _next(nullptr){}};template <class K, class V, class KeyOfT, class Hash>class HashTable;template <class K, class V,class Ref, class Ptr, class KeyOfT, class Hash = HashFunc<K>>struct __HTIterator{typedef HashNode<V> Node;typedef __HTIterator<K, V,Ref,Ptr, KeyOfT, Hash> Self;Node* _node;const HashTable<K, V, KeyOfT, Hash>* _pht;size_t hashi;__HTIterator(Node* node,const HashTable<K, V, KeyOfT, Hash>* pht,size_t i): _node(node), _pht(pht), hashi(i){}Self operator++(){if (_node->_next){_node = _node->_next;}else{++hashi;while (hashi < _pht->_tables.size()){if (_pht->_tables[hashi]){_node = _pht->_tables[hashi];break;}++hashi;}if (hashi == _pht->_tables.size()){_node = nullptr;}}return *this;}bool operator!= (const Self& s){return _node != s._node;}bool operator== (const Self& s){return _node == s._node;}Ref operator*(){return _node->_data;}Ptr operator->(){return &(_node->_data);}};template <class K, class V,class KeyOfT, class Hash = HashFunc<K>>class HashTable{typedef HashNode<V> Node;template <class K, class V,class Ref, class Ptr, class KeyOfT, class Hash>friend struct __HTIterator;public:typedef __HTIterator<K, V, V&, V*, KeyOfT, Hash> iterator;typedef __HTIterator<K, V, const V&,const V*,KeyOfT, Hash> const_iterator;iterator begin(){for (size_t i = 0; i < _tables.size(); i++){if (_tables[i]){return iterator(_tables[i], this, i);}}return end();}iterator end(){return iterator(nullptr, this, -1);}const_iterator begin() const{for (size_t i = 0; i < _tables.size(); i++){if (_tables[i]){return const_iterator(_tables[i], this, i);}}return end();}const_iterator end() const{return const_iterator(nullptr, this, -1);}HashTable(){_tables.resize(10);}~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 V& data){iterator ret = Find(kt(data));if (ret!=end()){return make_pair(ret,false);}if (_n == _tables.size()){//需要扩容vector<Node*> newtables;newtables.resize(2 * _tables.size());for (size_t i = 0; i < _tables.size(); i++){Node* cur = _tables[i];while (cur){Node* next = cur->_next;size_t hashi = hs(kt(cur->_data))% newtables.size();cur->_next = newtables[hashi];newtables[hashi] = cur;cur = next;}_tables[i] = nullptr;}_tables.swap(newtables);}size_t hashi = hs(kt(data)) % _tables.size();Node* cur = new Node(data);cur->_next = _tables[hashi];_tables[hashi] = cur;_n++;return make_pair(iterator(cur,this,hashi), true);}//__HTIterator<K, V, V&, V*, KeyOfT, Hash>// __HTIterator<K, V,Ref,Ptr, KeyOfT, Hash>iterator Find(const K& k){size_t hashi = hs(k) % _tables.size();Node* cur = _tables[hashi];while (cur){if (kt(cur->_data) == k){return iterator(cur,this,hashi);}cur = cur->_next;}return end();}bool Erase(const K& k){size_t hashi = hs(k) % _tables.size();Node* cur = _tables[hashi];Node* prev = nullptr;while (cur){if (cur->_kv.first == k){if (prev==nullptr){_tables[hashi] = cur->_next;}else{prev->_next = cur->_next;}delete cur;return true;}cur = cur->_next;}return false;}private:KeyOfT kt;vector<Node*> _tables;size_t _n = 0;Hash hs;};
}

封装的unordered_map

template<class K, class V>class unordered_map{struct MapKOfT{const K& operator()(const pair<const K, V>& kv){return kv.first;}};public:typedef typename hash_bucket::HashTable<K, pair<const K, V>, MapKOfT>::iterator iterator;typedef typename hash_bucket::HashTable<K, pair<const K, V>, MapKOfT>::const_iterator 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 = _ht.Insert(make_pair(key, V()));return ret.first->second;}private:hash_bucket::HashTable<K, pair<const K,V>,MapKOfT> _ht;};

封装的unordered_set

template<class K>
class unordered_set
{struct SetKOfT{const K& operator()(const K& key){return key;}};
public:typedef typename hash_bucket::HashTable<K, K, SetKOfT>::const_iterator iterator;typedef typename hash_bucket::HashTable<K, K, SetKOfT>::const_iterator const_iterator;iterator begin() const {return _ht.begin();}iterator end() const{return _ht.end();}pair<iterator, bool> insert(const K& key){auto ret = _ht.Insert(key);return make_pair(iterator(ret.first._node, ret.first._pht,ret.first.hashi), ret.second);}private:hash_bucket::HashTable<K, K,SetKOfT> _ht;
};