Memory leakage when creating object in a loop - c++

Question

I am new to C++ and memory management. I have a code that is to build up a graph composed of objects of type vertex(~100 bytes each) and edge(~ 50 bytes each). My code works fine when the graph is small, but with the real data that has ~ 3M vertexes and ~ 10M edges, I get the run time error: std::bad_alloc when "new" is used (and not always with the same new).
This, based on what I have gathered, is the effect of memory leakage in my program that makes new memory allocation fail. My question is what is wrong with the way I am allocating memory and more importantly how can I fix it. Here is roughly what I do:
In the graph class constructor I create the array repository for the objects of class vertex:
graph:graph()
{
// vertexes is a class varaible
vertexes = new vertex *[MAX_AR_LEN];// where MAX_AR_LEN = 3M
}
I then call a function like this to iteratively build obj vertexes and assign them to array.
void graph::buildVertexes()
{
for(int i=0; i<v_num; i++)
vertexes[i] = new vertex(strName);
}
I then complete other tasks and at the end before the program ends I have a destructor that explicitly deletes the graph object
graph:~graph()
{
delete[] vertexes;
vertexes = 0;
}
Where is the leak happening. I am creating a lot of objects but nothing to my knowledge that could be deleted and remains undeleted.
I have been dealing with this for over a week now with not much luck. Thank you very much for your help!
EDIT (after solving the issue):
Thanks all for the help. Looking back, with the info I provided it is hard to pinpoint what was going on. I solved the issues and here are the very obvious points that I took away; so obvious that might not worth sharing, but here they are anyway:
When dealing with lots of objects that need to exist on the memory simultaneously, before coding use your best estimation to find the minimal memory you need. In my case even without a leakage, I would have almost maxed out on memory. I just needed better estimates of memory use to figure that out.
As you go along developing your code, frequently using vld.h (or other alternatives) can be helpful in checking that your design is free of memory leakage. Doing this at the end could be a lot more complicated, and even if you find the leakage, it might be harder to fix.
Let’s say you did all these and you expect to have enough memory to run the code but you get std::bad_alloc run time error when there seems to be plenty of free memory available on your system. You might be compiling for 32 bit platform, switching to 64 bit will allow allocation of more memory from what’s available (for visual studio: ).
Use of vectors instead of arrays as suggested by many here is a helpful approach to avoid a common route for leakage (and for other conveniences), but let’s say you have memory leakage and you have arrays. As arrays are not necessarily the cause of leakage (obviously), switching to vectors might not serve you. Looking at array deletion though is a good start. Here is what I gathered for how to properly delete an array of pointers to objects:
//Let's say we have
objType **objAr = new objType[ aNum];
for(int i=0; i<objNum; i++)
{
ObjAr[i] = new objType();
}
// to delete:
for(int i=0; i<objNum; i++)
{
delete objAr[i];
}
// If instead of array of pointers we had just
// an array of objects loop wasn't needed
delete [] objAr;
objAr = 0;
Ironically, a source of leakage in my code was improper deletion of a vector of pointers to objects. For vectors I needed to first delete element by element and then do a vec.clear(). Just doing the latter was causing memory leakage.

Answer 1

Look how many times you use new. You use it once to allocate the array of pointers (new vertex *[MAX_AR_LEN]) and then you use it v_num times to allocate each vertex. To avoid memory leaks, you have to use delete the same number of times you use new, so that you deallocate everything that you allocated.
You're going to have to loop through your array of pointers and do delete vertexes[i] on each one.
However, if you had used a std::vector<vertex>, you would not have to deal with this manual memory allocation and would avoid these kinds of problems.
Note that the plural of "vertex" is "vertices"