Deleting dynamic arrays

Question

My main concern is worrying about having a memory leak due to a program crashing before it has the chance to reach the line of code in which technically releases its memory. What I do not understand is, if the program does crashes before it can release the memory of any dynamic arrays, wouldn't the memory leak still exist the next time you run the program and causing the leak to get worse each time?
for example, if I had something like this...
int main()
int *a = new int[10];
bool game = true;
// then for some reason the program crashes somewhere along these lines...
while(game) {
do some code in which some reason cause the program to crash
delete [] a;
return 0;
here in the example, if the program had crashed inside the while loop, wouldn't I have a memory leak which exist forever?

Answer 1

BnTheMan wrote:
The first instance is I wanted to know after reading some topics on the internet, I have heard that is is not a good Idea to set a pointer to know inside of a constructer class like this...
should you do this, or does it depend on the compiler that you use, and what about if you are using XCode?
Did you mean to type "not a good Idea to set a pointer to NULL"? That is what you code seems to say.
They key part is memory management. People have been screwing that up for decades. You should initialize pointers to NULL or 0 (same thing) before using them. Then, when you are done with them, if they aren't NULL, you must release them. Even if you haven't allocated a pointer, you can always release it if it is NULL using free(), delete, or release - depending on what language you are using.
If you allocate a pointer, then release its memory, you should re-set it back to NULL immediately if there is any chance that some other bit of code could try to release the memory. If you try to free a pointer twice, your app will crash.
All this is true in any environment that doesn't have garbage collection. Don't think that garbage collection is the panacea it is made out to be. It is better to be able to manage your own memory when you need to. Plus, there are more system resources than just memory.
2. The next thing I noticed was that it did not have any memory releasing code for when there is a problem with reading the file, such as if the file could not be opened. So I am wondering if something was to happen when opening the second MD2 file, in that it could not open the file because it was currupted, and I did something like this...
MD2_Object::loadObject() {
ifstream inFile;
char buffer[64];
inFile.open(myFile, istream::binary);
if(!inFile) {
... the code I need to my question
How can I tell the program that there was an error and that it needs to release the memory from the first dynamic array variable?
(I added some { code } statements to format your code nicely. Reply to this post to see how I did it.)
That is a good question, with several caveats. In your example, you are actually using static variables, not dynamic. All of your data is allocated on the stack. You didn't use any sort of malloc(), new, alloc, etc. Therefore, memory management is easy. When the current scope ends (usually the code between braces) anything allocated on the stack automatically goes away cleanly. Plus, since the stack is much more low level than dynamic memory, you can do stack allocations much more quickly.
But, had used dynamic allocation, this would be an issue. It is a significant problem that is rarely handled correctly. If there is an error, you need to release any resources (such as memory) that you have allocated. There are a number of ways to handle this, depending on your language and how you want to do it.
The first solution is to exploit the fact that, in C++, you can declare your variables anywhere you want. They don't have to be at the beginning of the scope. The best thing to do is don't allocate resources unless you know you can use them. If you fail halfway through, you would have to release all resources that you had allocated up to that point.
Some other ideas are to use exceptions and wrap allocations in classes such as auto_ptr. Then, when you encounter an error, you throw and exception and you use the stack scoping rules, though static wrapper variables, to release dynamic data underneath.
Yeah, it gets complicated. Maybe most more code that precisely shows what you are concerned with. Wrap your code between two lines of
{ code }
{ code }
without the spaces and it will print out nicely. So far, it looks like you are doing everything correctly. Sometimes, instead of asking how to do something, you'll get better responses by just posting how you do it and, if there are any problems, people will pick it apart Harsh, but effective.