use function in template only to specific type

[myoni]

Hi everyone
I want to use function in template only if typeid==string but I'mgetting this error:

Error 1 error C2440: 'type cast' : cannot convert from 'std::string' to '__int64'

this is the code:

if (typeid(K) == typeid(string))
	innerKey=stringToNumber(_key);
else
	innerKey=(long long int)_key;

and this is the full code:

#ifndef HashTable_H
#define HashTable_H

#include <iostream>
#include <string>
#include <iomanip>
#include <sstream>
#include "item.h"
using namespace std;



template <typename K, typename T>
class HashTable
{
	int size;
	friend long long int stringToNumber(string str);

	bool chkIfNumberIsPrime(int num)
	{
		bool flag=true;
		int numSqrt;
		numSqrt=(int)sqrt((double)num);

		for(int x=2;x<=numSqrt; x++)
			if (num % x ==0)
				return false;

		return true;
	}

	int calcPrimeNumber(int num)
	{
		while(!chkIfNumberIsPrime(num++));
		return num-1;
	}

	Item<K,T>* find(K _key)
	{
		Item<K,T>* ptr=NULL;
		int i=0;

		do
			ptr=&table[hash(_key,i++)];
			while (!(ptr->status==Item<K,T>::Status::empty) && ptr->key!=_key && i<=size);

		if(ptr->key==_key)
			return ptr;
		else
			return NULL;
	}

	long long int stringToNumber(string str)
	{
			long long int key=0;
			int size=str.length();
			int *arr = new int[size];
			int temp;

			for(int i=0; i<size; i++)
			{
				arr[i]=int(str[i]);
				temp=(int)pow((double)128,i);
				key+=arr[i]*temp;
			}

			delete []arr;
		return key;
	}
	
	

public:
	Item<K,T>* table;

	HashTable(int _size) 
	{ 
		table = new Item<K,T>[calcPrimeNumber(_size)]; 
		size=_size;
	}
	~HashTable() { delete []table; }

	int h2(int k) { return 1; }
	int h1(int k) { return k % size; }
	int hash(int k, int i) { return (h1(k)+i*h2(k)) % size; }



	bool hashInsert(K _key, T _value)
	{
		Item<K,T>* ptr=NULL;
		int i=0;
		long long int innerKey;

		
		
		//if (typeid(K) == typeid(string))
			innerKey=stringToNumber(_key);
		//else
		//	innerKey=(long long int)_key;
		
		//keyStr.assign(item->key);
		
		while ((ptr==NULL || ptr->status==Item<K,T>::Status::full) && i<=size)
			ptr=&table[hash(innerKey,i++)];

		if (i<=size)
		{
			ptr->key=_key;
			ptr->value=_value;
			ptr->status=Item<K,T>::Status::full;
			return true;
		}
		else 
		{
			cout<<"hash table overflow.\n";
			return false;
		}
	}

	Item<K,T>* hashSearch(K _key){ return (find(_key)); }

	

	//I understood that delete function get key and look for it. if it's found and the key equal the key in the node it deleted.
	bool hashDelete(K _key)
	{
		Item<K,T>* ptr=find(_key);
		if (ptr)
		{
			ptr->key=NULL;
			ptr->value=NULL;
			ptr->status=Item<K,T>::Status::deleted;
			return true;
		}
		else
			return false;	
	}

	friend ostream & operator<<<K,T>(ostream &os, HashTable<K,T> &ht);

	
	

	
};


//template <class K,class T>
//long long int stringToNumber(string str)
//		{
//			long long int key=0;
//			int size=str.length();
//			int *arr = new int[size];
//			int temp;
//
//			for(int i=0; i<size; i++)
//			{
//				arr[i]=int(str[i]);
//				temp=(int)pow((double)128,i);
//				key+=arr[i]*temp;
//			}
//
//			delete []arr;
//			return key;
//		}




template <class K, class T> 
ostream & operator<<(ostream &os, HashTable<K,T> &ht)
{
	Item<K,T> *item;
	string statusStr="", valueStr="", keyStr="";

	os<<left<<setw(7)<<"Key"<<left<<setw(7)<<"Value"<<setw(7)<<"Status"<<endl;
	os<<"--------------------\n";

	for (int x=0; x<ht.size; x++)
	{
		item=&ht.table[x];

		if ((item->key)==K())
			keyStr="NULL";
		else
		{
			//keyStr.assign(item->key);
			//if string 
				//keyStr=item->key;
			//else
			//	keyStr=to_string((long long)item->key);
		}
		
		if ((item->value)==T())
			valueStr="NULL";
		else
		{
			//if string 
				valueStr=item->value;
			//else
				//valueStr=to_string((long long)item->value);
		}

		switch(item->status)
		{
			case -1: statusStr="deleted"; break;
			case  0: statusStr="empty";	break;
			case  1: statusStr="full"; break;
		}
		os<<left<<setw(7)<<keyStr<<left<<setw(7)<<valueStr<<setw(7)<<statusStr<<endl;
	}
	return os;
}

#endif 

#ifndef Item_H
#define Item_H

#include <iostream>
#include <typeinfo>
#include <string>
using namespace std;



template <class K, class T>
class Item
{
public:	
	enum Status {empty=0, full=1, deleted=-1};
	K key;
	T value;
	Status status;

	Item();
	bool operator!=(Item<K,T> &item);
	friend ostream & operator<<<K,T>(ostream & os, Item<K,T> & item);
};


template <class K, class T>
Item<K,T>::Item()
{
	key=K();
	value=T();
	//value=NULL;
	status=empty;
}


template <class K, class T> 
bool Item<K,T>::operator!=(Item<K,T> &item)
{
	return (this->key==item.key && this->value==item.value && this->status==item.status);
}

template <class K, class T>
ostream & operator<<(ostream & os, Item<K,T> & item)
{
	string statusStr;

	if (&item)
	{
		switch(item.status)
		{
			case -1: statusStr="deleted"; break;
			case  0: statusStr="empty";	break;
			case  1: statusStr="full"; break;
		}
		os<<left<<setw(5)<<"key: "<<setw(5)<<item.key<<"\tvalue: "<<setw(5)<<item.value<<"\tstatus: "<<setw(5)<<statusStr<<endl;
		return os;
	}
	else
		return (ostream)NULL;
}

#endif 

#include <iostream>
#include <string>
#include "Lecture.h"
#include "HashTable.h"


using namespace std;

void main()
{
	
	//system("color 1f");

	HashTable<int,int> hs1(3);
	//HashTable<string,int> hs1(3);

	cout<<hs1<<endl<<endl;

	hs1.hashInsert(12,1);
	//hs1.hashInsert("pt",1);
	cout<<hs1<<endl<<endl;



	//cout<<"dd";

	system("pause");
}

[Peter87]

So stringToNumber is your hash function for strings. It's easier if you use the a hash function with the same name for all types. Then you can use the same code in HashTable for all types.

You can use a template function that returns key as it is. For types like std::string that needs to work differently you just specialize the template function for that type.

template <typename T>
long long int hashNumber(const T& key)
{
	return key;
}

template <>
long long int hashNumber(const string& str)
{
	long long int key=0;
	int size=str.length();
	int *arr = new int[size];
	int temp;
	for(int i=0; i<size; i++)
	{
		arr[i]=int(str[i]);
		temp=(int)pow((double)128,i);
		key+=arr[i]*temp;
	}

	delete []arr;
	return key;
}

[myoni]

amazing, thanks a lot