HashTable Keeps producing segFault. How to properly delete using destructor? - c++

Question

I have a HashTable class. The purpose of this is to practice how to produce Hash Table. My current issue right now is the destructor. I should be seeing on the console, this:
But instead i see this:
I've ran gdb ./app which gives me this:
#include <iostream>
#include "HashTable.h"
using namespace std;
int main(){
HashTable table;
table.initTable();
table.addNode("Software");
table.addNode("Engineering");
table.addNode("Art");
table.addNode("Programming");
table.addNode("Miscellanous");
table.displayByIndex();
return 0;
}
HashTable Header:
#ifndef _HASHTABLE_H_
#define _HASHTABLE_H_
#include <iostream>
#include "Hash.h"
class HashTable{
private:
static const int TABLESIZE = 5;
Hash* head;
public:
HashTable();
~HashTable();
void initTable();
int hashKey(char*);
int quadProbing(int,int);
int hashKeyWithProbing(char*);
bool isEmpty();
void addNode(char*);
void displayByIndex();
void searchByKey(char*);
};#endif
Here it my Hash Table CPP, i included the Constructor/Destructor and init functions. The other functions arent included since i dont utilize the 'new' keyword. If its needed i will include it [hope to make this thread small]
#include "HashTable.h"
#include <cstring>
HashTable::HashTable(){
head = new Hash[TABLESIZE];
}
HashTable::~HashTable(){
Hash* destList = NULL;
for(int i = 0; i< TABLESIZE; i++){
destList = &head[i];
while(destList != NULL){
head = head->getNext();
delete destList;
destList = head;
}
}
head = NULL;
delete [] head;
}
void HashTable::initTable(){
for(int i = 0; i < TABLESIZE; i++){
Hash *traverseHeadArray = &head[i];
traverseHeadArray->setKey("EMPTY");
traverseHeadArray->setNext(NULL);
traverseHeadArray = NULL;
}
}
int HashTable::hashKey(char *tempKey){
//Find the asc value for the string
//add them together
//modules by the total table size
//then return the index (remainder using modules)
//Index is were that key will be stored
int index = 0;
for(int i = 0; i < strlen(tempKey); i++){
index += tempKey[i];
}
return index % TABLESIZE;
}//DONE
int HashTable::quadProbing(int index, int counter){
return (index + counter*counter) % TABLESIZE;
}//DONE
int HashTable::hashKeyWithProbing(char* key){
int index = hashKey(key);
int count = 1;
while(head[index].getKey() != key && head[index].getKey() != "EMPTY"){
index = quadProbing(index, count);
count++;
}
return index;
}//DONE
void HashTable::addNode(char* tempValue){
Hash* newNode = new Hash;
newNode->setKey(tempValue);
newNode->setNext(NULL);
int index = hashKey(tempValue);
int counter = 1;
while(head[index].getKey() != tempValue && head[index].getKey() !="EMPTY")
{
index = quadProbing(index, counter);
counter++;
}
Hash* traverse = &head[index];
if(isEmpty() || traverse->getKey() == "EMPTY"){
traverse->setKey(newNode->getKey());
traverse->setNext(newNode->getNext());
}else{
while(traverse->getNext() != NULL)
traverse = traverse->getNext();
traverse->setNext(newNode);
}
traverse = NULL;
delete newNode;
}
void HashTable::displayByIndex(){
for(int i = 0; i < TABLESIZE; i++){
Hash *traverse = &head[i];
std::cout << "----------------------------------------" << std::endl;
std::cout << "INDEX: " << i << std::endl;
while(traverse != NULL){
std::cout << "Key: " << traverse->getKey() << std::endl;
traverse = traverse->getNext();
}
std::cout << "----------------------------------------" << std::endl;
traverse = NULL;
}
}
bool HashTable::isEmpty(){
return (head == NULL);
}
void HashTable::searchByKey(char* key){
int index = hashKeyWithProbing(key);
if(isEmpty())
std::cout << "Empty Bucket\n";
else{
Hash* traverse = &head[index];
while(traverse != NULL && traverse->getKey() != "EMPTY"){
std::cout << "TOPIC KEY: " << traverse->getKey() << std::endl;
traverse = traverse->getNext();
}
traverse = NULL;
}
}
Here is my Hash Class header and CPP files:
#ifndef _HASH_H_
#define _HASH_H_
class Hash{
private:
char* key;
Hash* next;
public:
Hash();
~Hash();
void setKey(char*);
void setNext(Hash* const);
char* getKey();
Hash* getNext();
};#endif
#include "Hash.h"
#include <iostream>
Hash::Hash(){
key = NULL;
next = NULL;
}
Hash::~Hash(){
// TODO Destructor
}
void Hash::setKey(char* tempKey){
this->key = tempKey;
}
void Hash::setNext(Hash* const tempNext){
this->next = tempNext;
}
char* Hash::getKey(){
return key;
}
Hash* Hash::getNext(){
return next;
}

Answer 1

In your code, you allocating only the getNext() nodes,
so you should delete only them, (you tried to delete &head[i] which wasn't allocated at all).
There is still an exception for double freeing some node, you should debug and follow the stack for figuring it out.
HashTable::~HashTable(){
for(int i = 0; i< TABLE_SIZE; i++){
Hash* node = head[i].getNext();
while(node != nullptr){
Hash* temp = nullptr;
if (node -> getNext()) {
temp = node->getNext();
}
delete node;
node= temp;
}
}
delete[] head;
}
Output:
----------------------------------------
INDEX: 0
Key: Art
----------------------------------------
----------------------------------------
INDEX: 1
Key: Engineering
----------------------------------------
----------------------------------------
INDEX: 2
Key: Miscellanous
----------------------------------------
----------------------------------------
INDEX: 3
Key: Software
----------------------------------------
----------------------------------------
INDEX: 4
Key: Programming
----------------------------------------
double free or corruption (fasttop)
Process finished with exit code 134 (interrupted by signal 6: SIGABRT)