hashtable errors

[genclik27]

Where is the mistake, I do not understand the errors. It says;

'HashTable<HashedObj>::ITEM_NOT_FOUND' uses undefined class 'HashedObj'
1> with
1> [
1> HashedObj=HashedObj
1> ]
1> d:\users\suuser\documents\visual studio 2010\projects\ziv-lempel\ziv-lempel\hashtable.h(58) : see reference to class template instantiation 'HashTable<HashedObj>' being compiled
1> with
1> [
1> HashedObj=HashedObj
1> ]
1>d:\users\suuser\documents\visual studio 2010\projects\ziv-lempel\ziv-lempel\hashtable.h(61): warning C4018: '<' : signed/unsigned mismatch
1>d:\users\suuser\documents\visual studio 2010\projects\ziv-lempel\ziv-lempel\hashtable.h(30): error C2079: 'HashTable<HashedObj>::HashEntry::element' uses undefined class 'HashedObj'
1> with
1> [
1> HashedObj=HashedObj
1> ]
1> d:\users\suuser\documents\visual studio 2010\projects\ziv-lempel\ziv-lempel\hashtable.h(62) : see reference to class template instantiation 'HashTable<HashedObj>::HashEntry' being compiled
1> with
1> [
1> HashedObj=HashedObj
1> ]

#ifndef HASHTABLE_H
#define HASHTABLE_H
#include <vector>

using namespace std;

template <class HashedObj>
class HashTable
{
public:
	explicit HashTable( const HashedObj & notFound, int size = 101 );
	HashTable( const HashTable & rhs )
		: ITEM_NOT_FOUND( rhs.ITEM_NOT_FOUND ),
		array( rhs.array ), currentSize( rhs.currentSize ) { }

	const HashedObj & find( const HashedObj & x ) const;

	void makeEmpty( );
	void insert( const HashedObj & x );
	void remove( const HashedObj & x );

	const HashTable & operator=( const HashTable & rhs );

	enum EntryType { ACTIVE, EMPTY, DELETED };


private:
	struct HashEntry
	{
		HashedObj element;
		EntryType info;

		HashEntry( const HashedObj & e = HashedObj( ), EntryType i = EMPTY )
			: element( e ), info( i ) { }
	};

	vector<HashEntry> array;
	int currentSize;
	const HashedObj ITEM_NOT_FOUND;          

	bool isActive( int currentPos ) const;
	int findPos( const HashedObj & x ) const;
	void rehash( );
};


/**
* Construct the hash table.
*/
template <class HashedObj>
HashTable<HashedObj>::HashTable( const HashedObj & notFound, int size )
	: ITEM_NOT_FOUND( notFound ), array(  nextPrime( size )  )         
{
	makeEmpty( );      
}


void HashTable<class HashedObj>::makeEmpty()
{
currentSize = 0;
for( int i = 0; i < array.currentSize(); i++ )
array[ i ].info = EMPTY;
}


/**
* Method that performs quadratic probing resolution.
* Return the position where the search for x terminates.
*/
template <class HashedObj>
int HashTable<HashedObj>::findPos( const HashedObj & x ) const
{
	int collisionNum = 0;
	int currentPos = hash( x, array.size( ) );

	while( array[ currentPos ].info != EMPTY && 
		array[ currentPos ].element != x )
	{
		currentPos += 2 * ++collisionNum - 1;  // add the difference
		if( currentPos >= array.size( ) )             // perform the mod
			currentPos –= array.size( );                // if necessary
	}
	return currentPos;
}


/**
* Return true if currentPos exists and is active.
*/
template <class HashedObj>
bool HashTable<HashedObj>::isActive( int currentPos ) const
{
	return array[ currentPos ].info == ACTIVE;
}


/**
* Remove item x from the hash table.
*  x has to be in the table
*/
template <class HashedObj>
void HashTable<HashedObj>::remove( const HashedObj & x )
{
	int currentPos = findPos( x );
	if( isActive( currentPos ) )
		array[ currentPos ].info = DELETED;
}


/**
* Find item x in the hash table.
* Return the matching item, or ITEM_NOT_FOUND, if not found.
*/
template <class HashedObj>
const HashedObj & HashTable<HashedObj>::find( const HashedObj & x ) const
{
	int currentPos = findPos( x );
	if (isActive( currentPos )) 
		return array[ currentPos ].element; 
	return   ITEM_NOT_FOUND;
}


/**
* Insert item x into the hash table. If the item is
* already present, then do nothing.
*/
template <class HashedObj>
void HashTable<HashedObj>::insert( const HashedObj & x )
{
	// Insert x as active
	int currentPos = findPos( x );
	if( isActive( currentPos ) )
		return;
	array[ currentPos ] = HashEntry( x, ACTIVE );

	// enlarge the hash table if necessary 
	if( ++currentSize >= array.size( ) / 2 )
		rehash( );
}


/**
* Expand the hash table.
*/
template <class HashedObj>
void HashTable<HashedObj>::rehash( )
{
	vector<HashEntry> oldArray = array;

	// Create new double-sized, empty table
	array.resize( nextPrime( 2 * oldArray.size( ) ) );
	for( int j = 0; j < array.size( ); j++ )
		array[ j ].info = EMPTY;

	// Copy table over
	currentSize = 0;
	for( int i = 0; i < oldArray.size( ); i++ )
		if( oldArray[ i ].info == ACTIVE )
			insert( oldArray[ i ].element );
}


bool isPrime( int n )
{
	if( n == 2 || n == 3 )
		return true;

	if( n == 1 || n % 2 == 0 )
		return false;

	for( int i = 3; i * i <= n; i += 2 )
		if( n % i == 0 )
			return false;

	return true;
}


/**
* Internal method to return a prime number at least as large as n.
* Assumes n > 0.
*/
int nextPrime( int n )
{
	if( n % 2 == 0 )
		n++;
	for( ; !isPrime( n ); n += 2 )
		;
	return n;
}
#endif 

main.cpp

#include <stdlib.h>
#include <iostream>
#include <string.h>
#include "hashtable.h"
#include <vector>

using namespace std;


int main()
{
	HashTable< int > h(10);
system("PAUSE");
return 0;
}

[Peter87]

void HashTable<class HashedObj>::makeEmpty()
should be

template <class HashedObj>
void HashTable<HashedObj>::makeEmpty()

[genclik27]

Thank you very much. I do not know how I misses that.