Segmentation Fault on HashMap Implementation C++ - c++

Question

The code for my implementation of a hashmap can be found below. I'm not exactly sure why it's seg. faulting. I believe it's something to do with the constructor or destructor, but can't seem to figure exactly what.
typedef struct _node
{
char *key;
int value; /* For this, value will be of type int */
struct _node *next; /* pointer to the next node in the list */
} node;
/* HashMap class */
class HashMap
{
private:
node ** hashTable;
int numSlots;
public:
/* Initializes a hashmap given its set size */
HashMap(int size)
{
numSlots = size;
hashTable = new node*[size] ;
for (int i = 0; i < size; i++)
{
hashTable[i] = NULL;
}
}
/* Deconstructor */
~HashMap()
{
for (int i = 0; i < numSlots; i++)
{
node *temp = hashTable[i];
if (temp != NULL)
{
delete temp;
}
}
delete [] hashTable;
}
/*** Hash function. ***/
int hash(char *s)
{
int i;
int sum = 0;
for (i = 0; * (s + i) != '\0'; i++)
{
sum += *(s + i);
}
return (sum % numSlots);
}
/*
*Free all the nodes of a linked list. Helper method for *deconstructor
*/
void free_list(node *list)
{
node *temp;
char *tempKey;
int tempValue;
while (list != NULL)
{
temp = list;
tempKey = temp->key;
tempValue = temp->value;
list = list->next;
if (tempKey != NULL)
{
delete(tempKey);
}
delete(temp);
}
}
/* Create a single node. */
node *create_node(char *key, int value)
{
node *result = new node();
result->key = key;
result->value = value;
result->next = NULL;
return result;
}
/*
*Stores given key/value pair in hashmap
*returns boolean for success/failure
*/
void set (char* key, int value)
{
int keyValue = hash(key);
node *current = hashTable[keyValue];
node *original = current;
node *newNode;
if (current == NULL)
{
hashTable[keyValue] = create_node(key, value);
}
else
{
while (current != NULL)
{
current = current -> next;
}
if (current == NULL)
{
newNode = create_node(key, value);
newNode -> next = original;
hashTable[keyValue] = original;
}
}
}
/* Return a float value representing the load factor
*(item in hash map)/(size of hash map) of the data structure.
*/
float load()
{
float numUsed = 0.0;
for (int i = 0; i < numSlots; i++)
{
if (hashTable[i] != NULL)
{
numUsed++;
}
}
return (numUsed / numSlots);
}
/* Removes value corresponding to inputted key from table */
int remove (char* key)
{
int keyValue = hash(key);
node *listOfInterest = hashTable[keyValue];
if (listOfInterest == NULL)
{
return -999;
}
int toReturn = listOfInterest -> value;
delete(listOfInterest);
return toReturn;
}
/*
* Look for a key in the hash table. Return -999 if not found.
* If it is found return the associated value.
*/
int get(char *key)
{
int keyValue = hash(key);
node *listOfInterest = hashTable[keyValue];
while (listOfInterest != NULL)
{
if (listOfInterest != NULL)
{
return listOfInterest->value;
}
listOfInterest = listOfInterest -> next;
}
return -999;
}
/* Prints hash table */
void print_hash_table()
{
int i;
node *listIterator = NULL;
for (i = 0 ; i < numSlots ; i++)
{
listIterator = hashTable[i];
while (listIterator != NULL)
{
printf("%s %d\n", listIterator->key, listIterator -> value);
listIterator = listIterator -> next;
}
}
}
};

Answer 1

One likely crash is caused by create_node which stores an arbitrary pointer to a string via
result->key = key;
I'll be that you call it with some pointer to char that is destined to be soon inappropriately out of scope. Perhaps struct node should use a std::string to make it more likely to work. Or at least copy the string and create a destructor for node to dispose of that memory if you prefer C-style pointers.
Also, try Valgrind. I'm pretty sure that the problem will be noted.