Memory leak in program with class inheritance in c++

Question

Following is the code snippet:

class Create_size_one_Nodes  : public Adjacency_list
{
public:
    Create_size_one_Nodes()
    {
        nodes_hashtable = NULL;                 
        //adds the nodes present in the graph to the hashtable
        create_nodes_hashtable();   
    }

    ~Create_size_one_Nodes()
    {
        delete(nodes_hashtable);
        nodes_hashtable = NULL;
        count_size_one_nodes_created = 0;
    }
};

class Adjacency_list
{
protected :
//create a hash table that collects the nodes already created
//the key of the hashtable is the start value of the node
//the end of the node acts as the unique object indentifier
Hashtable *nodes_hashtable;

//given the hashtable,updates the values in the hashtable
void create_nodes_hashtable();
public :

//creates the adjacency list
Adjacency_list()
{   
    nodes_hashtable = NULL;

}

//after the adjcency list has been created
//clears the contents of the adjacency list
~Adjacency_list()
{
    delete(nodes_hashtable);
    nodes_hashtable = NULL;
}
};

//given the hashtable,updates the values in the hashtable
void Adjacency_list ::  create_nodes_hashtable()
{
//remove the pointer from the previous set position
nodes_hashtable = new(std::nothrow) Hashtable(WINDOW_LENGTH *HASHTABLE_SCALING_FACTOR);

  //check :if the hashtable has been created
  if(NULL == nodes_hashtable)
  {
    string error_message = "void Adjacency_list ::  create_nodes_hashtable() , the hash table hasnot been created";
    cerr<<error_message<<endl;
  }

for(unsigned int i = 0;i< no_of_valid_nodes ;i++)
{       
    //normalising the key ,so that the key lies within the range of the hashtable
    int key = get_nodes_hashtablekey(node_start[i],node_end[i]);
    (*nodes_hashtable).add_element(key,node_end[i],i);
}

}

[update]:

class Hashtable
{

private :

//counts the number of elements added into the hashtable
unsigned int count_elements_added;

//counts the number of elements removed from the hashtable
unsigned int count_elements_removed;

//counts the number of elements present in the hashtable
unsigned int count_elements_present;

//sets the size of the hashtable
unsigned int hashtable_size;

//the data structure (vector) that contains the objects
//the position on the hastable is defined by 2 keys
//one the position in the array of the hashtable : the start of the node is used
//the second is the first element in the pair present in the hash table //end of the node is used
std :: vector< std :: vector<std :: pair<int,int> > > hashtable;

//intialize the hashtable
void intialize_hashtable();

//checks whether the hashtable is corrupted or not
//returns true,if the hashtable is corrupted
//else returns false
bool is_corrupt();

public :

Hashtable()
{
    hashtable_size = DEFAULT_HASHTABLE_SIZE;
    hashtable.clear();
    intialize_hashtable();

    //counts the number of elements added into the hashtable
    count_elements_added = 0;

    //counts the number of elements removed from the hashtable
    count_elements_removed = 0;

    //counts the number of elements present in the hashtable
    count_elements_present = 0;
};

Hashtable(int hash_table_size)
{
    hashtable.clear();
    hashtable_size = hash_table_size;
    intialize_hashtable();

    //counts the number of elements added into the hashtable
    count_elements_added = 0;

    //counts the number of elements removed from the hashtable
    count_elements_removed = 0;

    //counts the number of elements present in the hashtable
    count_elements_present = 0;
};

//add elemnet to the hashtable
void add_element(int key,int object_identifier,int object_info);

//given the key and the object identifier
//returns the object info
int get_element(int key,int object_identifier);

//delete the element from the hashtable
void remove_element(int key,int object_identifier);

//prints the contents of the hashtable
void print();

~Hashtable()
{
    hashtable_size = 0;
    hashtable.clear();

    //counts the number of elements added into the hashtable
    count_elements_added = 0;

    //counts the number of elements removed from the hashtable
    count_elements_removed = 0;

    //counts the number of elements present in the hashtable
    count_elements_present = 0;

};
};

The object of create_size_one_nodes is created in main. But when it goes out of scope, memory is not freed.

Create_size_one_Nodes create_size_one_Nodes_object;
create_size_one_Nodes_object.create_nodes_size_one();

I am not able to delete the memory in delete(nodes_hastable). valgrid points out leak in the code. the vakgrind output is:

==16451== 27,692 (28 direct, 27,664 indirect) bytes in 1 blocks are definitely lost in loss record 7 of 7
==16451==    at 0x402A208: operator new(unsigned int, std::nothrow_t const&) (in /usr/lib/valgrind/vgpreload_memcheck-x86-linux.so)
==16451==    by 0x80E05FF: Adjacency_list::create_nodes_hashtable() (adjacency_list.cpp:75)

Please guide me on how to remove this memory leak

Answer 1

You will need to supply some extra information.

What type is nodes_hashtable? The creat_nodes_hashtable method.

There could be several things wrong but without more info it's impossible to know:

a) nodes_hashtable is really an array and the correct way to dealocate would be delete[] nodes_hashtable;

b) create_nodes_hashtable is actually doing more allocation that we don't know about, or is allocating stuff and not assigning it to nodes_hashtable or whatever.

Regards, V. Seguí

Answer 2

• Make the base class destructor as Virtual

• you don't actually need to delete nodes_hashtable here as it is allocated only when create_nodes_hashtable() function is called , ie do it inside Create_size_one_Nodes destructor

  //after the adjcency list has been created //clears the contents of the adjacency list ~Adjacency_list() { /* delete here is not required as create_nodes_hashtable() is not called inside this class. Ideally whoever allocated memory should free.But No harm if you keep */ delete(nodes_hashtable);
nodes_hashtable = NULL; }