无序系列关联容器的哈希封装--哈希表迭代器

开放定址法比较简单，这里我们主要实现连定址法

和之前一样，我们封装需要增加迭代器、和他的基本操作，还有KeyOfT，然后再遇到什么问题我们详细说

首先第一个问题是，我们要把数据类型从原来的key、value模式转化为模板，变成这种形式

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

		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 __HTIterator<K, T, Ref, Ptr, KeyOfT, Hash> Self;

		Node* _node;
		const HashTable<K, T, KeyOfT, Hash>* _pht;
		size_t _hashi;

		__HTIerator(Node* node, HashTable<K, T, KeyOfT, Hash>* pht, size_t hashi)
			:_node(node)
			, _pht(pht)
			, _hashi(hashi) {}

		__HTIerator(Node* node, const HashTable<K, T, KeyOfT, Hash>* pht, size_t hashi)
			:_node(node)
			, _pht(pht)
			, _hashi(hashi) {}

		Self& operator++() {}
		Ref operator*() {}
		Ptr operator->() {}

		bool operator!=(const Self& s) {}

	};

这里的迭代器因为要访问哈希表，所以需要前置声明，访问哈希表的话，我们给一个pht指向他的节点的指针，然后给一个对应的哈希地址

具体实现

		Self& operator++() {
			if (_node->_next != nullptr) {
				_node = _node->_next;
			}
			else {
				_hashi++;
				while (_hashi < _pht->_tables.size()) {
					if (_pht->_tables[_hashi]!=nullptr);
					{
						_node = _pht->_tables[_hashi];
						break;
					}
					_hashi++；
				}
				
				if (_hashi == _pht->_tables.size()) {
					_node = nullptr;
				}
			}
			return *this;
		}

		Ref operator*() {
			return _node->_data;
		}
		Ptr operator->() {
			return &_node->_data;
		}

		bool operator!=(const Self& s) {
			return _node != s._node;
		}

这里实现++主要有一个难点，就是当一个哈希桶走完的时候，我们如何找到下一个有效的哈希桶，一种思路是当场直接计算，取到下一个表中的值，计算出对应的哈希地址，第二种是直接现场推演，只要没有走出整个表，当我们找到一个不为空的节点时，这就是++的下一个位置，如果一直走出了表，就说明到了结尾，赋值为空即可

指针，引用，不等于，这里很简单