Recently I had a project which had some of the worst memory leaks in C++ i’ve ever had to deal with. It had just about every memory leak problem you could think of, all of which could have been solved with a little bit of planning.
So if you have a nightmarish C++ project with memory leaks, heres a few ways in which you can solve them.
Stage 1: Forgetfulness
We start off with a simple case: when you make an object but never delete it. e.g.:
Which can be solved by:
Stage 2: Garbage Collection
Sometimes you have a pointer to an object which is re-assigned at one point, but the old object is never deleted.
Which can be solved by deleting the object before re-assigning:
Stage 3: Destructors
Some people assume if you make a couple of classes like this:
If you destroy an instance of Woo both ~Woo and ~Foo will be called. Only it wont: only ~Woo will be called. Anything you free in ~Foo will never be freed.
So if you want ~Foo to be called too, the destructor for Foo needs to be virtual, i.e.:
Stage 4: Spaghetti
Things start getting complicated when you have objects which can be referenced by multiple objects. For example:
Now when do we delete foo? If we make child1 or child2 delete it, we’ll probably get a crash when we delete foo twice. If we delete it elsewhere, how do we know child1 or child2 aren’t still using it?
One possible solution is to use a reference counting system like in Objective C, so when we reach 0 we delete the object:
If you want to be more fancy you can make a smart pointer class, e.g.
Beware however that when you get a circular reference your objects may never be released using this method.
Stage 5: Runaway Spaghetti
Even if you have a reference counting system, you might encounter situations where you release or retain objects too much. Typically memory leak tools only tell you where objects were allocated, not who the retain/release culprit is.
One way of solving this is to keep track of where you retain and release objects
Then you can simply examine your logs and spot the problematic line of code for that extra release or retain.
Of course once you have solved all of your leaks, you might find you bump into the arch nemesis: Memory Corruption. Specifically, this:
What is wrong with this? Well say we have some code like this….
Then think may never be called, since mNextThink is never initialized, so its value will be undefined. It could be 0, it could be -10000. Who knows. The solution is simple:
With all of your memory leaks solved, you should now be able to sleep better.