"Incomplete Type" when open hashing c++ - c++11

Question

Im new to C++ and I'm getting an error which I've never seen before. I am attempting to search by a backtracking algorithm that uses a hash table (open hashing).
Before I make a recursive call, I'm searching the hash table to see if the current position has been searched before (and has failed) and then inserting vector of ints "B" into the hash table when the recursive call returns false so that future search for the same position can be avoided.
Heres my function in my program calling file to hash:
bool open_hash_solve (vector<int> B, vector<Move> & MS, vector<Move> & TMS, OpenHashTable<vector<int>> & H) {
if (solved(B))
return true;
vector<Move> curr = currentMoves(B, TMS);
for (int m = 0; m < curr.size(); m++) {
vector<int> moveMade = makeMove(B, curr[m]);
if (!H.contains(moveMade)){
if (open_hash_solve(moveMade, MS, TMS, H)){
MS.insert(MS.begin(), curr[m]);
return true;
}
else
H.insert(moveMade);
}
}
return false;
}
Header file Separate Chaining from the textbook:
#ifndef SEPARATE_CHAINING_H
#define SEPARATE_CHAINING_H
#include <vector>
#include <list>
#include <string>
#include <algorithm>
#include <functional>
using namespace std;
int nextPrime( int n );
// SeparateChaining Hash table class
//
// CONSTRUCTION: an approximate initial size or default of 101
//
// ******************PUBLIC OPERATIONS*********************
// bool insert( x ) --> Insert x
// bool remove( x ) --> Remove x
// bool contains( x ) --> Return true if x is present
// void makeEmpty( ) --> Remove all items
template <typename HashedObj>
class OpenHashTable
{
public:
explicit OpenHashTable( int size = 101 ) : currentSize{ 0 }
{ theLists.resize( 101 ); }
bool contains( const HashedObj & x ) const
{
auto & whichList = theLists[ myhash( x ) ];
return find( begin( whichList ), end( whichList ), x ) != end( whichList );
}
void makeEmpty( )
{
for( auto & thisList : theLists )
thisList.clear( );
}
bool insert( const HashedObj & x )
{
auto & whichList = theLists[ myhash( x ) ];
if( find( begin( whichList ), end( whichList ), x ) != end( whichList) )
return false;
whichList.push_back( x );
// Rehash; see Section 5.5
if( ++currentSize > theLists.size( ) )
rehash( );
return true;
}
bool insert( HashedObj && x )
{
auto & whichList = theLists[ myhash( x ) ];
if( find( begin( whichList ), end( whichList ), x ) != end( whichList ) )
return false;
whichList.push_back( std::move( x ) );
// Rehash; see Section 5.5
if( ++currentSize > theLists.size( ) )
rehash( );
return true;
}
bool remove( const HashedObj & x )
{
auto & whichList = theLists[ myhash( x ) ];
auto itr = find( begin( whichList ), end( whichList ), x );
if( itr == end( whichList ) )
return false;
whichList.erase( itr );
--currentSize;
return true;
}
private:
vector<list<HashedObj>> theLists; // The array of Lists
int currentSize;
void rehash( )
{
vector<list<HashedObj>> oldLists = theLists;
// Create new double-sized, empty table
theLists.resize( nextPrime( 2 * theLists.size( ) ) );
for( auto & thisList : theLists )
thisList.clear( );
theLists.resize( nextPrime( 2 * theLists.size( ) ) );
for( auto & thisList : theLists )
thisList.clear( );
// Copy table over
currentSize = 0;
for( auto & thisList : oldLists )
for( auto & x : thisList )
insert( std::move( x ) );
}
size_t myhash( const HashedObj & x ) const
{
static hash<HashedObj> hf; ***** ERROR HERE *****
return hf( x ) % theLists.size( );
}
};
#endif
My Error:
SeparateChaining.h: In instantiation of ‘size_t OpenHashTable<HashedObj>::myhash(const HashedObj&) const [with HashedObj = std::vector<int>; size_t = long unsigned int]’:
SeparateChaining.h:33:44: required from ‘bool OpenHashTable<HashedObj>::contains(const HashedObj&) const [with HashedObj = std::vector<int>]’
movetest1.cpp:107:29: required from here
SeparateChaining.h:106:34: error: ‘std::hash<std::vector<int> > hf’ has incomplete type
static hash<HashedObj> hf;
^
How do I fix this??
Let me know if my description doesn't make sense or needs clarity. Thanks in advance!

Answer 1

The reason is that std::hash is not defined for std::vector except std::vector<bool>. It's defined only for basic types and select library types. You have to implement your own hashing algorithm.
Regarding your last comment, hash( x ) is invalid code since std::hash is a class template, not a function template.
You also can't write your own specialization for std::hash<std::vector<int>> since std::vector<int> is not a user-defined type.
Appropriate solution would be in the style of C++ standard library - OpenHashTable should allow its user to specify hashing algorithm:
template<typename HashedObj, typename Hash = std::hash<HashedObj>>
class OpenHashTable {
// ...
size_t myhash(const HashedObj& x) const {
static Hash hf;
return hf(x) % theLists.size();
}
};
So you can use it as follows:
struct my_vector_int_hash {
size_t operator()(const std::vector<int>& v) const {
// your code here
}
};
OpenHashTable<std::vector<int>, my_vector_int_hash> hashtable;
Update: as long as discussion arose about whether you can specialize std::hash<std::vector<int>>, here is why you are not allowed to do it.
[namespace.std]/1 says:
The behavior of a C++ program is undefined if it adds declarations or definitions to namespace std or to a namespace within namespace std unless otherwise specified. A program may add a template specialization for any standard library template to namespace std only if the declaration depends on a user-defined type and the specialization meets the standard library requirements for the original template and is not explicitly prohibited.
std::vector<int> is not a user-defined type, nor it depends on any user-defined type, so such specialization is illegal and leads to undefined behavior.