Error when deallocating double pointer in c++ - c++

Question

I am having to build a Cuckoo Hash table. When deallocating my "full" hash tables so that I can resize them and rehash all of my values (from an external file of ints), I get the error:
*** glibc detected *** ./a.out: free(): invalid pointer: 0x09c83c7c ***
======= Backtrace: =========
/lib/i386-linux-gnu/libc.so.6(+0x75002)[0x6b1002]
/usr/lib/i386-linux-gnu/libstdc++.so.6(_ZdlPv+0x18)[0x918fa8]
/usr/lib/i386-linux-gnu/libstdc++.so.6(_ZdaPv+0x18)[0x919008]
./a.out[0x8049678]
/lib/i386-linux-gnu/libc.so.6(__libc_start_main+0xf3)[0x655533]
./a.out[0x8048b11]
I am not all that familiar with double pointers but the code was working fine with them untill I tried to deallocate, which I do as follows:
for(int j = 0; j < currentSize; j++)
{
if(HT1[j] != NULL)
{
delete [] HT1[j];
}
if(HT2[j] != NULL)
{
delete [] HT2[j];
}
}
delete [] HT1;
delete [] HT2;
I have a line in the code (cout.ignore()) to pause everytime the program rehashes so I can see whats going on every time it does so. Hit enter to continue the code.
Thanks for any help!
#include <iostream>//cin and cout
#include <fstream>//file stream
using namespace std;
/***********************************
/Function:
/Arguments:
/Return:
***********************************/
class Value
{
public:
Value();
Value(int newValue);
~Value();
int value;
bool h1;
bool h2;
};
/***********************************
/Function:Default constructor for Value class
/Arguments:
/Return:
***********************************/
Value::Value()
{
value = 0;
h1 = 0;
h2 = 0;
}
/***********************************
/Function:Overloaded constructor for Value class
/Arguments:
/Return:
***********************************/
Value::Value(int newValue)
{
value = newValue;
h1 = 0;
h2 = 0;
}
Value::~Value(){};
/***********************************
/Function: Print the hash tables
/Arguments: Value HT1[]
Value HT2[]
int tableSize
/Return:None
***********************************/
void printArrays(Value **table1, Value **table2, int tableSize)
{
//print out hash table 1 and 2
cout << "Hash Table 1 Hash Table 2" << endl;
cout << "------------ ------------" << endl;
for(int i = 0; i < tableSize; i++)
{
cout.width(2);
cout << right << i << ". ";
if(table1[i] == NULL)
{
std::cout.width(8);
cout << std::left << '0';
}
else
{
std::cout.width(8);
cout << std::left << table1[i]->value;
}
cout << " ";
cout.width(2);
cout << right << i << ". ";
if(table2[i] == NULL)
{
cout << "0" << endl;
}
else
{
cout << table2[i]->value << endl;
}
}
cout << endl;
}
/***********************************
/Function:
/Arguments:
/Return:
***********************************/
int hash1(int value, int currentSize)
{
return value % currentSize;
}
/***********************************
/Function:
/Arguments:
/Return:
***********************************/
int hash2(int value, int currentSize)
{
return (value/currentSize)%currentSize;
}
/***********************************
/Function:Finds the smallest prime number
greater than 2* tableSize
/Arguments: int tableSize
/Return: prime int
***********************************/
int findPrime(int size)
{
int rehashSize = (size) * 2 + 1;
bool prime = 1;
for(int i = 2; i < rehashSize/2; i++)
{
if(rehashSize % i == 0)
{
rehashSize++;
i = 2;
}
}
return rehashSize;
}
int main()
{
int next;//Stores value from file stream
int const tableSize = 11;//Size of the hash table
int currentSize = tableSize;//Stores the current HT size
int rehashSize;//Holds the size of a rehashed table
int hash; //Holds the hash value
int hashTable = 1;//Governor of the switch statement
Value **HT1 = new Value* [tableSize];//Hash Table 1
Value **HT2 = new Value* [tableSize];//Hash Table 2
Value *current;//Stores the value currently being hashed
Value *temp;//Temporarily holds a Value object if booted from its hash table
ifstream ifs;//file steam object
ifs.open("raw_int.txt");//open file stream to file
while(!(ifs.eof()))
{
for(int i = 0; i < currentSize; i++)
{
HT1[i] = NULL;
HT2[i] = NULL;
}
printArrays(HT1, HT2, currentSize);
ifs >> next;
current = new Value(next);
while(!(current->h1 == 1 && current->h2 == 1))
{
cout << "BEFORE - next / hashTable / current / h1 / h2 :: " << next << " " << hashTable << " " << current->value << " " <<
current->h1 << " " << current->h2 << endl;
cout << "ARRAY BEFORE" << endl;
printArrays(HT1, HT2, currentSize);
switch(hashTable)
{
case 1:
cout << "IN CASE 1\n\n";
hash = hash1(current->value, currentSize);
cout << "HASH 1: " << hash << endl;
if(HT1[hash] == NULL)
{
HT1[hash] = current;
HT1[hash]->h1 = 1;
ifs >> next;
current = new Value(next);
}
else
{
temp = HT1[hash];
HT1[hash] = current;
HT1[hash]->h1 = 1;
current = temp;
hashTable = 2;
}
break;
case 2:
cout << "IN CASE 2\n\n";
hash = hash2(current->value, currentSize);
cout << "HASH 2: " << hash << endl;
if(HT2[hash] == NULL)
{
HT2[hash] = current;
HT2[hash]->h2 = 1;
ifs >> next;
current = new Value(next);
hashTable = 1;
}
else
{
temp = HT2[hash];
HT2[hash] = current;
HT2[hash]->h2 = 1;
current = temp;
hashTable = 1;
}
break;
}
cout << "AFTER - next / hashTable / current / h1 / h2 :: " << next << " " << hashTable << " " << current->value << " " <<
current->h1 << " " << current->h2 << endl;
cout << "ARRAY AFTER: " << endl;
printArrays(HT1, HT2, currentSize);
}
rehashSize = findPrime(currentSize);
for(int j = 0; j < currentSize; j++)
{
if(HT1[j] != NULL)
{
delete [] HT1[j];
}
if(HT2[j] != NULL)
{
delete [] HT2[j];
}
}
delete [] HT1;
delete [] HT2;
currentSize = rehashSize;
Value **HT1 = new Value* [currentSize];
Value **HT2 = new Value* [currentSize];
//printArrays(HT1, HT2, currentSize);
ifs.seekg(0, ifs.beg);
cout << "\n\n\n\n\n";
cout << "---------------------------------------REHASHED:NEW SIZE / CURRENT: " << currentSize << " " << current->value << " ----------------------------------------------" << endl;
cout << "\n\n\n\n\n";
cin.ignore();
}
printArrays(HT1, HT2, currentSize);
return 0;
}

Answer 1

I think one of the the issues might be in this segment:
delete [] HT1;
delete [] HT2;
currentSize = rehashSize;
Value **HT1 = new Value* [currentSize];
Value **HT2 = new Value* [currentSize];
You are (always) deleting the HT1 and HT2 allocated at the beginning of main, but the new then assigns to newly created local variables (but on next iteration the original arrays get deleted again, not the new ones).
Try to remove the Value ** when doing new (to assign to the existing variables):
delete [] HT1;
delete [] HT2;
currentSize = rehashSize;
HT1 = new Value* [currentSize];
HT2 = new Value* [currentSize];
which could fix the deletion of the same pointer multiple times.
(and the same also applies for the for loop, where you are again deleting the items multiple times in next iterations)
Also, if you are rehashing, normally you would allocate the new tables before getting rid of the old ones and putting the old items to the new tables first.
EDIT
When looked closer at the for loop, the items should not be deleted by the delete[], because they are allocated via new, not via new[], try to change to:
for(int j = 0; j < currentSize; j++)
{
delete HT1[j];
delete HT2[j];
}
(no need to check for NULL, because delete called on NULL pointer skips the deletion automatically)