const members and operator= - c++

Question

I have a struct with some const variables
struct HashData
{
const HashKey key;
const void* data;
HashData(const HashKey& key_, const void* data_) : key(key_), data(data_) {}
/* How to write this ?
HashData operator=(const HashData & data)
{
key = std::move(data.key);
return *this;
}
*/
};
and another class where i use it.
class HashTable
{
std::vector< std::list<HashData> > hashTable; ///< Collisions resolution by chaining.
public:
void insertAtIndex(const std::size_t index, const HashData& data) {
hashTable[index].insert(std::begin(hashTable[index]), data);
}
};
class HashTable compiles but another class
class OpenAddressHashTable
{
std::vector<HashData> hashTable;
public:
void insert(const HashData & data) throw() {
if (data.key == NULLKEY)
throw std::runtime_error("Do not use NullKey");
size_t iteration = 0;
do {
const size_t index = (*hashFunc)(data.key, iteration);
if (hashTable[index].key == NULLKEY) {
// space is free
// ** IMPORTANT **///// Line 131 is next line
hashTable[index] = data;
return ;
}
iteration++;
} while(iteration < hashTable.size());
throw std::runtime_error("No space left");
}
};
I get this error :
g++ -W -Wall -pedantic -std=c++11 hash.cpp
hash.cpp: In member function 'void OpenAddressHashTable::insert(const HashData&)':
hash.cpp:131:24: error: use of deleted function 'HashData& HashData::operator=(const HashData&)'
hash.cpp:26:8: note: 'HashData& HashData::operator=(const HashData&)' is implicitly deleted because the default definition would be ill-formed:
hash.cpp:26:8: error: non-static const member 'const HashKey HashData::key', can't use default assignment operator
What is it that std::list does that i need to put the data in my vector ?
Do i need to use pointers in my hashTable ?

Answer 1

You are doing an assignment:
hashTable[index] = data;
There is simply no way for that to work if you have const members because you cannot copy or move into const. The compiler error is pretty explicit:
[the assignment operator] is implicitly deleted because the default definition would be ill-formed
What would you expect the assignment to do to key and data? The simplest thing would be to drop the const and enforce it on your interface with the user - so that they cannot change the key out from under you. For instance:
using InternalHashData = std::pair<HashKey, void*>;
using ExternalHashData = std::pair<const HashKey, void*>;
InternalHashData& something_to_be_returned = ..; // never expose this
return reinterpret_cast<ExternalHashData&>(something_to_be_returned); // this is OK
The only way I can think of to keep the const would be to change your table from:
std::vector<HashData> hashTable;
to
std::vector<std::unique_ptr<HashData>> hashTable;
But then you're doing an extra allocation on each insert just to preserve const-ness, which doesn't seem like a good tradeoff to me at all, especially for a container whose sole purpose is performance.

Answer 2

The compiler deletes the assignment operator for the class HashData because it has constant fields (key and data). This makes sense since you can't assign something to a const member, therefore the object were the const member is living is shouldn't be assigned ether.
Your HashData class is inmutable. This could be ok if you want the class to be so, but the assignment in your class OpenAddressHashTable can not be performed because of the inmutability.
Also regarding your "const void* data" field: Really more C++ like would be to use generics here.
You could do something like this:
template<typename T>
struct HashData
{
HashKey key; // delete the const if you really want to modify a instance of HashData
T data;
HashData(const HashKey& key_, T data_) : key(key_), data(data_) {}
};
And T will be the type of your mapped value. This of couse will force you that all your values have the same type, which might be not a problem.

Answer 3

hashTable[index].insert(std::begin(hashTable[index]), data);
Will insert a new HashData object at the front of the linked-list held at the index. This means a call to a copy constructor, which is defined by default for HashData. (A default copy constructor copy constructs all its members, and const members are copy construable since you are setting an initial value, not overwriting an existing one)
hashTable[index] = data;
Will assign to an existing HashData object, but assignment is deleted by default for HashData. (All its members are nonassignable because you've declared them all as const)
What you could do instead is have the members of HashData as non-const, but return only const references and const iterators to the private vector in OpenAddressHashTable. This will keep your HashData objects as const everywhere except where they are actually managed, which seems to be your goal.