模仿stl，实现了hashtable。纯属练手，只实现其基本功能，不当之处还望指正。本文为实现独立的空间配置器。

#include<iostream>
#include<vector>
#include<algorithm>
using namespace std;
template<class value>
struct _hash_node{
	value val;
	_hash_node *next;
	~_hash_node(){delete val;}
};
template<class value,class key,class HashFcn,class EqualKey>
class _hashtable;
template<class T1,class T2>
class _hashfcn_mod;
template<class value,class key,class HashFcn,class EqualKey>
class _hashtable_iterator{
public:
	typedef _hashtable<value,key,HashFcn,EqualKey> hashtable;
	typedef _hashtable_iterator<value,key,HashFcn,EqualKey> iterator;
	typedef _hash_node<value> node;
	typedef forward_iterator_tag iterator_category;
	typedef value value_type;
	typedef ptrdiff_t difference_type;
	typedef size_t size_type;
	typedef value& reference;
	typedef value* pointer;
	node* cur;
	hashtable* ht;
	iterator(node* n,hashtable* tab):cur(n),ht(tab){}
	iterator(){}
	reference operator*()const{return cur->val;}
	pointer operator->()const{return &(operator*()); }
	iterator& operator++(){
		const node* old = cur;
		cur = cur->next; //需要判断cur的next是否存在
		if(!cur){ //若此bucket list已经遍历到null 则继续向下一个bucket移动
			size_type bucket = ht->bkt_num(old->val);
			while(!cur&& ++bucket < ht->buckets.size())
				cur = ht->buckets[bucket];
		}
		return *this;
	}
	iterator operator++(int){
		const iterator old = cur;
		++*this;
		return old;
	}
	bool operator==(const iterator& it)const{return cur == it.cur;}
	bool operator!=(const iterator& it)const{return cur != it.cur;}
};
static const int _stl_num_primes = 28; //保存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, 3221225473ul, 4294967291ul 
};

//获取大于等于n的第一个质数
inline unsigned long _stl_next_prime(unsigned long n){
	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 value,class key,class HashFcn,class EqualKey>
class _hashtable{
public:
	typedef HashFcn hasher;
	typedef EqualKey key_equal;
	typedef value value_type;
	typedef key key_type;
	typedef value_type& reference;
	typedef size_t size_type;
	typedef _hash_node<value> node;
	typedef _hashtable_iterator<value,key,HashFcn,EqualKey> iterator;
	vector<node*> buckets;
private:
	hasher hash; //哈希映射函数
	key_equal equals;
	size_type num_elements;
private:
	void initialize_buckets(size_type n){
		const size_type n_buckets = next_size(n);
		buckets.reserve(n_buckets);
		buckets.insert(buckets.end(), n_buckets, (node*) 0);
		num_elements = 0;
	}
	size_type next_size(size_type n)const{return _stl_next_prime(n);}
	void copy_from(const _hashtable& ht) {
		buckets.clear();
		buckets.reserve(ht.buckets.size());
		buckets.insert(buckets.end(), ht.buckets.size(), (node*) 0);
		try {
			for (size_type i = 0; i < ht.buckets.size(); ++i) {
				if (const node* cur = ht.buckets[i]) {
					node* copy = new_node(cur->val);
					buckets[i] = copy;
 
					for (node* next = cur->next; next; cur = next, next = cur->next) {
						copy->next = new_node(next->val);
						copy = copy->next;
					}
				}
			}
			num_elements = ht.num_elements;
		}
		catch(...){
			clear();
		}
	}
	node* new_node(const value_type& obj)
	{
		node* n = allocate((node*)0);
		n->next = 0;
		try {
			construct(&n->val, obj);
			return n;
		}
		catch(...){
			deallocate(n);
			exit(1);
		}
	}
	template<class T>
	T* allocate(T* a,ptrdiff_t size=1){
		set_new_handler(0);
		T* tmp = (T*)(::operator new((size_t)(size*sizeof(T))));
		if(tmp == 0){
			cerr<<"out of memory."<<endl;
			exit(1);
		}
		return tmp;
	}
	template<class T1,class T2>
	void construct(T1* p,const T2& value){new (p)T1(value);}
	template<class T>
	void deallocate(T* buffer){::operator delete(buffer);}
	void clear(){
		for (size_type i = 0; i < buckets.size(); ++i) {
			node* cur = buckets[i];
			while (cur != 0) {
				node* next = cur->next;
				delete_node(cur);
				cur = next;
			}
			buckets[i] = 0;
		}
		num_elements = 0;
	}
	void delete_node(node* n)
	{
		destroy(&n->val);
		deallocate(n);
	}
	template <class T>
	void destroy(T* pointer) {
		pointer->~T();
	}
	size_type bkt_num_key(const key_type& key) 
	{
		return bkt_num_key(key, buckets.size());
	}
	size_type bkt_num_key(const key_type& key, size_t n) 
	{
		return hash(key,n);// % n;
	}
	iterator insert_equal_noresize(const value_type& obj){
		size_type n = bkt_num(obj);
		node* first = buckets[n];
		for(node* cur=first;cur;cur=cur->next){
			if(equals(get_key(cur->val),get_key(obj))){
				node* tmp = new_node(obj);
				tmp->next = cur->next;
				cur->next = tmp;
				++num_elements;
				returniterator(tmp,this);
			}
		}
		node* tmp = new_node(obj);
		tmp->next = first;
		buckets[n] = tmp;
		return iterator(tmp,this);
	}
	pair<iterator, bool> insert_unique_noresize(const value_type& obj){
		const size_type n = bkt_num(obj);
		node* first = buckets[n];
 
		for (node* cur = first; cur; cur = cur->next) 
			if (equals(get_key(cur->val), get_key(obj)))
				return pair<iterator, bool>(iterator(cur, this), false);
 
		node* tmp = new_node(obj);
		tmp->next = first;
		buckets[n] = tmp;
		++num_elements;
		return pair<iterator, bool>(iterator(tmp, this), true);
	}
	value_type get_key(const value_type& obj){
		ExtractKey<value_type> tmp;
		return tmp(obj);
	}
public:
	size_type bucket_size(){return buckets.size();}
	_hashtable(size_type n,const HashFcn& hf,const EqualKey& eql):hash(hf),equals(eql){
		initialize_buckets(n);
	}
	_hashtable(const _hashtable& ht):hash(ht.hash),equals(ht.equals),num_elements(0){
		copy_from(ht);
	}
	_hashtable(){clear();}
	size_type bucket_count()const{return buckets.size();}
	size_type max_bucket_count()const{return _stl_prime_list[_stl_num_primes - 1];}
	size_type elems_in_bucket(size_type bucket)const{
		size_type result = 0;
		for(*node cur = buckets[bucket];cur;cur = cur->next)
			result += 1;
		return result;
	}
	size_type bkt_num(const value_type& obj)
	{
		return bkt_num_key(get_key(obj));
	}
	size_type bkt_num(const value_type& obj, size_t n) const
	{
		return bkt_num_key(get_key(obj), n);
	}
	void resize(size_type num_elements_hint){
		_hashfcn_mod<value_type,value_type> hashfcn_mod;
		const size_type old_n = buckets.size();
		if(num_elements_hint > old_n){
			const size_type n = next_size(num_elements_hint);
			if(n > old_n){
				vector<node*> tmp(n,(node*)0);
				try{
					for(size_type bucket=0;bucket<old_n;++bucket){
						node* first = buckets[bucket];
						while(first){
							size_type new_bucket = hashfcn_mod(first->val,n);
							buckets[bucket] = first->next;
							first->next = tmp[new_bucket];
							tmp[new_bucket] = first;
							first = buckets[bucket];
						}
					}
					buckets.swap(tmp);
				}
				catch(...){
					for(size_type bucket=0;bucket<tmp.size();++bucket){
						while(tmp[bucket]){
							node* next = tmp[bucket]->next;
							delete_node(tmp[bucket]);
							tmp[bucket] = next;
						} 
					}
					throw;
				}
			}
		}
	}
	pair<iterator,bool> insert_unique(const value_type& obj){
		resize(num_elements+1);
		return insert_unique_noresize(obj);
	}
	iterator insert_equal(const value_type& obj)
	{
		resize(num_elements + 1);
		return insert_equal_noresize(obj);
	} 
	iterator begin()
	{ 
		for (size_type n = 0; n < buckets.size(); ++n)
			if (buckets[n])
				return iterator(buckets[n], this);
		return end();
	}
	iterator end() { return iterator(0, this); }
	size_type erase(const key_type& key)
	{
		const size_type n = bkt_num_key(key);
		node* first = buckets[n];
		size_type erased = 0;
		if (first) {
			node* cur = first;
			node* next = cur->next;
			while (next) {
				if (equals(get_key(next->val), key)) {
					cur->next = next->next;
					delete_node(next);
					next = cur->next;
					++erased;
					--num_elements;
				}
				else {
					cur = next;
					next = cur->next;
				}
			}
			if (equals(get_key(first->val), key)) {
				buckets[n] = first->next;
				delete_node(first);
				++erased;
				--num_elements;
			}
		}
		return erased;
	}
	void erase(const iterator& it)
	{
		if (node* const p = it.cur) {
			const size_type n = bkt_num(p->val);
			node* cur = buckets[n];
 
			if (cur == p) {
				buckets[n] = cur->next;
				delete_node(cur);
				--num_elements;
			}
			else {
				node* next = cur->next;
				while (next) {
					if (next == p) {
						cur->next = next->next;
						delete_node(next);
						--num_elements;
						break;
					}
					else {
						cur = next;
						next = cur->next;
					}
				}
			}
		}
	}
	reference find_or_insert(const value_type& obj){
		resize(num_elements + 1);
		size_type n = bkt_num(obj);
		node* first = buckets[n];
 
		for (node* cur = first; cur; cur = cur->next)
			if (equals(get_key(cur->val), get_key(obj)))
		return cur->val;
 
		node* tmp = new_node(obj);
		tmp->next = first;
		buckets[n] = tmp;
		++num_elements;
		return tmp->val;
	}
	iterator find(const key_type& key){
		size_type n = bkt_num_key(key);
		node* first;
		for ( first = buckets[n];first && !equals(get_key(first->val), key);
			first = first->next);
		return iterator(first, this);
	} 
	void erase(iterator first, iterator last){
		size_type f_bucket = first.cur ? bkt_num(first.cur->val) : buckets.size();
		size_type l_bucket = last.cur ? bkt_num(last.cur->val) : buckets.size();
		if (first.cur == last.cur)return;
		else if (f_bucket == l_bucket)erase_bucket(f_bucket, first.cur, last.cur);
		else {
			erase_bucket(f_bucket, first.cur, 0);
			for (size_type n = f_bucket + 1; n < l_bucket; ++n)
				erase_bucket(n, 0);
			if (l_bucket != buckets.size())
				erase_bucket(l_bucket, last.cur);
		}
	}
};
/*****************************************************
此函数对象用于定义映射函数，根据自己的需求可以定义线性探测、
二次线性探测或者自定义函数
***********************************************************/
template<class T1,class T2>
class _hashfcn_mod{ //简单取余映射 
public:
	T1 operator()(T1 value,T2 size){ //value为key值  size为bucket长度
		return value % size;
	}
};

/*************************************************************
判断键值是否相等的函数，可自定义
*************************************************************/
template<class T>
class _key_equal{
public:
	bool operator()(T t1,T t2){
		return t1 == t2;
	}
};

/************************************************************
从节点中取出键值的方法，可自定义
***********************************************************/
template<class T>
class ExtractKey{  //从节点取出键值
public:
	T operator()(const T& tmp){
		identity<T> id;
		return id(tmp);
	}
};

void test1(){
	_hashfcn_mod<int,int> hashfcn;
	_key_equal<int> keyequal;
	_hashtable<int,int,_hashfcn_mod<int,int>,_key_equal<int>> hashtab(20,hashfcn,keyequal);
	hashtab.insert_unique(15);
	hashtab.insert_unique(14);
	hashtab.insert_unique(13);
	hashtab.insert_unique(12);
	_hashtable<int,int,_hashfcn_mod<int,int>,_key_equal<int>>::iterator iter;
	for(iter = hashtab.begin();iter!= hashtab.end();++iter)
		cout<<*iter<<" ";
	cout<<endl;
	hashtab.erase(12);
	for(iter = hashtab.begin();iter!= hashtab.end();++iter)
		cout<<*iter<<" ";
	cout<<endl;
	hashtab.erase(hashtab.find(13));
	for(iter = hashtab.begin();iter!= hashtab.end();++iter)
		cout<<*iter<<" ";
	cout<<endl;
}
int main(){
	test1();
}