hash.h

班级通讯录c++编写

template<class B,class H,class T>class bucketHashVectorIterator;
template<class B,class H,class T> class bucketHashVector;
template<class T>class iterator;
template<class T> class listIterator;

template<class K,class V>class dictionaryTable
:public bucketHashVector<dictionaryList<K,V>,K,association<K,V>*>{
	public:
		dictionaryTable(unsigned int max,unsigned int(*f)(const K&));
		dictionaryTable(unsigned int max,unsigned int(*f)(const K&),V&);
		V & operator[](K key);
		void removeKey(K key);
		void setInitial(V initialValue);
		int includesKey(K key);
	protected:
		iterator<association<K,V>*>*makeIterator(unsigned i);
};

template<class K,class V>iterator<association<K,V>*>* dictionaryTable<K,V>::
makeIterator(unsigned int i){
	listIterator<association<K,V>*> itr(buckets[i].data);
	t1=itr;
	return  &t1;
}

template<class K,class V>dictionaryTable<K,V>::
dictionaryTable(unsigned int max,unsigned int(*f)(const K&)):
bucketHashVector<dictionaryList<K,V>,K,association<K,V>*>(max,f){}

template<class K,class V>dictionaryTable<K,V>::
dictionaryTable(unsigned int max,unsigned int(*f)(const K&),V&v):
bucketHashVector<dictionaryList<K,V>,K,association<K,V>*>(max,f){
	setInitial(v);
}
template<class K,class V>int dictionaryTable<K,V>::includesKey(K key){
	return buckets[hash(key)].includesKey(key);
   
}
template<class K,class V>void dictionaryTable<K,V>::setInitial(V val)
{
	for(unsigned i=0;i<tablesize;i++)
		buckets[i].setInitValue(val);
}
template<class K,class V>V &dictionaryTable<K,V>::operator [](K key){
	return buckets[hash(key)][key];
}
template<class K,class V>void dictionaryTable<K,V>::removeKey(K key){
	buckets[hash(key)].removeKey(key);
}
///////////////////////////////////////////////////////
template<class K,class V>class dictionaryTableIterator:
public bucketHashVectorIterator<dictionaryList<K,V>,K,association<K,V>*>
{
	public:
		dictionaryTableIterator(dictionaryTable<K,V>&v);
};
template<class K,class V>dictionaryTableIterator<K,V>::
dictionaryTableIterator(dictionaryTable<K,V>&d):
bucketHashVectorIterator<dictionaryList<K,V>,K,association<K,V>*>(d){}

/////////////////////////////////////////////////////////////////////
template<class B,class H,class T>class bucketHashVectorIterator:public iterator<T>{
	public:
		//construct function
		bucketHashVectorIterator(bucketHashVector<B,H,T>& v);
		bucketHashVectorIterator(const bucketHashVectorIterator &);
		virtual int init();
		virtual T operator()();
		virtual int operator!();
		virtual int operator++();
		virtual void operator=(T value);
	protected:
		bucketHashVector<B,H,T>& base;
		unsigned int currentIndex;
		iterator<T>* itr;
		int getNextIterator();
};
template<class B,class H,class T>bucketHashVectorIterator<B,H,T>::
bucketHashVectorIterator(bucketHashVector<B,H,T>& s):base(s),currentIndex(0),itr(0){}
template<class B,class H,class T>bucketHashVectorIterator<B,H,T>::
bucketHashVectorIterator(const bucketHashVectorIterator<B,H,T>& s):
base(s),currentIndex(s.currentIndex),itr(s.itr){}
template<class B,class H,class T>T bucketHashVectorIterator<B,H,T>::operator()(){
	return (*itr)();
}
template<class B,class H,class T>int bucketHashVectorIterator<B,H,T>::operator!(){
    return currentIndex<base.tablesize;
}
template<class B,class H,class T> void bucketHashVectorIterator<B,H,T>::
operator=(T value){}//???????
template<class B,class H,class T>int bucketHashVectorIterator<B,H,T>::init(){
	currentIndex=0;
	itr=0;
	return getNextIterator();
}
template<class B,class H,class T>int bucketHashVectorIterator<B,H,T>::getNextIterator(){
	//if(itr!=0)delete itr;//the teacher said there are something wrong.!
	for(;currentIndex<base.tablesize;currentIndex++){
		itr=base.makeIterator(currentIndex);
		assert(itr!=0);
		if(itr->init())return 1;
		//delete itr;
	}
	itr=0;
	return 0;
}
template<class B,class H,class T>int bucketHashVectorIterator<B,H,T>::operator++(){
	if(itr&&(*itr)++)return 1;
	currentIndex++;
	return getNextIterator();
}
///////////////////////////////////////////////////////////////
template<class B,class H,class T>class bucketHashVector{
	public:
		//constructer function
		bucketHashVector(unsigned int max,unsigned int (*f)(const H &));
		virtual int isEmpty();//judged is empty?
		virtual void deleteAllValues();//delete All Values
	protected:
		friend class bucketHashVectorIterator<B,H,T>;
		unsigned int tablesize;
		vector<B> buckets;
		unsigned int (*hashfun)(const H &);
		unsigned int hash(const H&key)const;
		virtual iterator<T>*makeIterator(unsigned int)=0;
};
template<class B,class H,class T> bucketHashVector<B,H,T>::bucketHashVector(unsigned int max,unsigned(*f)(const H &)):
tablesize(max),hashfun(f),buckets(max){
	// vector<B> itr(max);
	 //buckets=itr;
}
template<class B,class H,class T>void bucketHashVector<B,H,T>::deleteAllValues(){
	for(unsigned i=0;i<tablesize;i++)
		buckets[i].deleteAllValues();
}
template<class B,class H,class T>int bucketHashVector<B,H,T>::isEmpty(){
	for(unsigned i=0;i<tablesize;i++)
		if(!buckets[i].isEmpty())return 0;
		return 1;
}
template<class B,class H,class T>unsigned int bucketHashVector<B,H,T>::hash(const H&key)const{
	return(*hashfun)(key)%tablesize;
}