Searching Hashed Values in Hash Table

[simplicity740]

I'm working on a programming assignment where I need to implement Quadratic Probing to create a hash table with the states of the United Stated and keeps track of each state's information. The state information is read from a text file. The state's name is used as the key to determine the hash address. The program can be tested by searching for and removing certain states from the hash table.
However, there seems to be a problem with the search function, because it does not return the hashed values when a searched is performed on the hash table, instead it returns the values (state names) from the address where the function originally attempted to put the state. Searching a value that has not been hashed does not give any problems. So, the problem appears to be with the search function (void search(int& hashIndex, elemType& rec, bool& found) cons), or maybe I need to re-define the 'getstateInfo'.
When I use a debugger, it seems like the above mentioned search function is skipped. The code is below.
I would appreciate any help or input that would direct me to a possible solution.

Thanks in advance.

 
template <class elemType>
class hashT
{
public:
	void insert(int hashIndex, elemType& rec);
	
	void search(int& hashIndex, elemType& rec, bool& found) const;
	
	bool isItemAtEqual(int hashIndex, const elemType& rec) const;
	
	void retrieve(int hashIndex, elemType& rec) const;
	
	void remove(int hashIndex, elemType& rec);
	
	void print() const;
	
	int hashFunction(string name);
	
	hashT(int size = 101);
	
	~hashT();
	
private:
	elemType *HTable; 
	int *indexStatusList;
	int length; 
	int HTSize; 
};


template <class elemType>
void hashT<elemType>::insert(int hashIndex, elemType& rec)
{
	int pCount;
	int inc;

	pCount = 0;
	inc = 1;

	while (indexStatusList[hashIndex] == 1
		&& HTable[hashIndex] != rec
		&& pCount < HTSize / 2)
	{
		cout << "inc = " << inc << endl;
		pCount++;
		hashIndex = (hashIndex + inc) % HTSize;
		cout << "new hashIndex = " << hashIndex << endl;
		inc = inc + 2;
	}


	if (indexStatusList[hashIndex] != 1)
	{
		HTable[hashIndex] = rec;
//		cout << "HTable[" << hashIndex << "]" << "	= " << rec << endl;
		indexStatusList[hashIndex] = 1;
		length++;
	}
	else
	if (HTable[hashIndex] == rec)
		cerr << "Error: No duplicates are allowed" << endl;
	else
		cerr << "Error: The table is full. "
		<< "Unable to resolve the collision" << endl;
}


template <class elemType>
void hashT<elemType>::search(int& hashIndex, elemType& rec, bool& found)const
{
	int pCount;
	int inc;

	pCount = 0;
	inc = 1;
	
	while (indexStatusList[hashIndex] != -1
		&& HTable[hashIndex] != rec
		&& pCount < HTSize / 2)
	{
		pCount++;
		hashIndex == (hashIndex + inc) % HTSize;
    	inc = inc + 2;
	}

	if (indexStatusList[hashIndex] == 1 /*&& HTable[hashIndex] == rec*/)
	{
		rec = HTable[hashIndex];
		found = true;
	}
	else
	{
		found = false;
	}

}


template <class elemType>
void hashT<elemType>::remove(int hashIndex, elemType& rec)
{
//	bool found;
	
	if (indexStatusList[hashIndex] != 1)
	{
		cout << "State not found" << endl << endl;
		return;
	}
	else
	{
		indexStatusList[hashIndex] = -1;
		length--;
		cout << "State Deleted" << endl << endl;
	}
}


template <class elemType>
bool hashT<elemType>::isItemAtEqual(int hashIndex, const elemType& rec)const
{
	return(HTable[hashIndex] == rec);
}

template <class elemType>
void hashT<elemType>::retrieve(int hashIndex, elemType& rec)const
{
	if (indexStatusList[hashIndex] == 1)
		rec = HTable[hashIndex];
}


template <class elemType>
void hashT<elemType>::print()const
{
	for (int i = 0; i < HTSize; i++)
	if (indexStatusList[i] != 0)
		cout << i << "	" << indexStatusList[i]
		<< "	" << HTable[i] << endl;
}

template <class elemType>
hashT<elemType>::hashT(int size)
{
	assert(size > 0);

	HTable = new elemType[size];
	indexStatusList = new int[size];
	length = 0;
	HTSize = size;

	for (int i = 0; i < size; i++)
		indexStatusList[i] = 0;
}

template <class elemType>
hashT<elemType>::~hashT()
{
	delete[] HTable;
	delete[] indexStatusList;
}



class StateData
{
public:
	StateData();
	StateData(string, string);
	void setStateInfo(string, string);
	string getName();
	string getCapital();
	string getStateInfo();

	friend bool operator < (StateData &, StateData &);
	friend bool operator > (StateData &, StateData &);
	bool operator != (StateData& const);
	friend bool operator == (StateData &, StateData &);
	friend ostream &operator << (ostream&, StateData&);
	friend istream &operator >> (istream &, StateData &);

private:
	string name;
	string capital;
	
};


StateData::StateData()
{
	name = " ";
	capital = " ";
	
}

StateData::StateData(string n, string c) 
{
	name = n;
	capital = c;
	
}

void StateData::setStateInfo(string n, string c) 
{
	name = n;
	capital = c;
}

string StateData::getName()
{
	return name;
}

string StateData::getCapital()
{
	return capital;
}

//string StateData::getStateInfo()
//{
//	return ;
//}


bool operator<(StateData &right, StateData &left)
{
	return (right.getName() < left.getName());
}

bool operator>(StateData &right, StateData &left)
{
	return (right.getName() > left.getName());
}

bool operator==(StateData &right, StateData &left)
{
	return (right.getName() == left.getName());
}


bool StateData::operator!=(StateData &left)
{
	return (this->name != left.name);
}


ostream &operator << (ostream& out, StateData&a)
{
	cout << setw(18)<< left << a.getName() << a.getCapital() << endl;

	return out;
}

istream &operator>>(istream &in, StateData &a)
{
	string n, c;
	cout << "Enter State: ";
	getline(cin, n);
	cout << "Enter Capital: ";
	getline(cin, c);
	a.setStateInfo(n, c);
	return in;
}


int hashFunc(string name, int size);

int main()
{
	/*int x = 0;
	std::clock_t start;
	double duration;

	start = std::clock();*/



	hashT<StateData> HashTable(60);
	int size = 60;

	ifstream infile;

	infile.open("statesinfo.txt");
	if (!infile)
	{
		cout << "Error reading states file.\n";
		exit(1);
	}

	int key;
	string state, capital, name;
	StateData temp;
	bool found;
	int choice;
	found = false;

	getline(infile, state);

	while (infile)
	{
		getline(infile, capital);
		temp.setStateInfo(state, capital);
		key = hashFunc(state, size);
		HashTable.insert(key, temp);

		getline(infile, state);
	}

	cout << setw(6)<< "\n\nINDEX  " << "STATUS   " << setw(18) << left << "STATE" << "CAPITAL" << endl << endl;
	HashTable.print();

	while (1)
	{
		cout << "\n------------------------------------------------------------------------" << endl;
		cout << "                       Operations on Hash Table" << endl;
		cout << "\n------------------------------------------------------------------------" << endl;
		cout << "1.  Insert a state into the Hash Table" << endl << endl;
		cout << "2.  Search for a state in the Hash Table" << endl << endl;;
		cout << "3.  Delete a state from the Hash Table" << endl << endl;
		cout << "4.  Exit" << endl << endl;
		cout << "Enter your choice: ";
		cin >> choice;
		
		switch (choice)
		{
		case 1:
			while (key != 1)
			{
			cout << "Enter the state: ";
			getline(cin, state);
			getline(cin, state);
			cout << "Enter the capital: ";
			getline(cin, capital);

			key = hashFunc(state, size);			
			temp.setStateInfo(state, capital);
			HashTable.insert(key, temp);
			key = 1;
			}
			HashTable.print();
			break;
		case 2:
			cout << "Enter state to search: ";
			getline(cin, state);
			getline(cin, state);
			key = hashFunc(state, size);
			temp.setStateInfo(state, capital);
			HashTable.search(key, temp, found);
			cout << endl;

			if (found == true)
			{
				cout << "\nState Found: " << key << "  " << temp << endl;
			}
			else
			{
				cout << "\nState not found" << endl;
			}
			cout << endl;
			HashTable.print();
			break;
		case 3:
			cout << "Enter state to delete: ";
			getline(cin, state);
			getline(cin, state);
			key = hashFunc(state, size);
			temp.setStateInfo(state, capital);
			HashTable.remove(key, temp);
			HashTable.print();
			break;
		case 4:
			exit(1);
		default:
			cout << "\nThat is not a valid option. Choose either 1, 2, 3 or 4.\n";
		}
	}

	infile.close();
	return 0;

}

int hashFunc(string name, int size)
{
	int i, sum, len;
	i = 0;
	sum = 0;
	len = name.length();
	for (int k = 0; k < 15 - len; k++)
		name = name + ' ';
	for (int k = 0; k < 5; k++)
	{
		sum = sum + static_cast<int>(name[i]) * 128 * 128
			+ static_cast<int>(name[i + 1]) * 128
			+ static_cast<int>(name[i + 2]);
		i = i + 3;
	}
	return sum % size;
}

[cire]

However, there seems to be a problem with the search function, because it does not return the hashed values when a searched is performed on the hash table,

I think the actual problem is that you don't have a hash table. You may want to review whatever description you were given. Failing that, visit https://en.wikipedia.org/wiki/Hash_table and have a read.