How Do I Deal with Static Objects when Overloading new and delete to Find Memory Leaks?

Question

I'm trying to detect memory leaks by globally overloading new and delete for debug builds and maintaining a list of allocated blocks. This works, but incorrectly reports leaks for some static objects. For example a static std::vector itself is not allocated using new and delete but its internal buffers are. Since my detection code runs before the main function returns the destructors of these objects are not yet called so they haven't deleted their buffers yet and this appears as a "leak".

One workaround I've found is by deleting and placement newing each static object to clear out their buffers before I check for leaks:

std::vector<int> f;

f.~std::vector<int>();
new (&f) std::vector<int>();

This is really ugly though and including cleanup code that isn't required seems bad. Is there some way of getting my code to run after the statics have been destroyed? (even if it's Microsoft-specific)

Answer 1

You need to look into std::allocator - the second template parameter of almost all STL containers.

Answer 2

You could try using an atexit handler.

Answer 3

Write a function which empties your list of allocated blocks. Call it after all static initialization, but before your program starts allocating anything you want to track. First thing in main() should do it. Of course you'll still see leaks for static vectors which have resized, so you might want to reserve them bigger to start with in leak-detection mode. If a static vector is inexorably growing over time, then you probably want to know about that and treat it as a leak even though it's static.

Edit in response to comment:

For example, instead of one central bit of code to destroy all globals at shutdown time:

template<typename T> 
class Reserve {
     Reserve(T &t, typename T::size_type size) {
         t.reserve(size);
     }
};

static std::vector<int> foo;
static Reserve<std::vector<int> > foo_r(foo, 50);

static std:string bar;
static Reserve<std::string> bar_r(bar, 256);

There might be something you can do with a function template, so that type inference gets rid of the need to repeat the type. How about:

template<typename T>
int reserve(T &t, typename T::size_type size) {
    t.reserve(size);
    return 0;
}

static std::vector<int> foo;
static int foo_r = reserve(foo, 50);

static std:string bar;
static int bar_r = reserve(bar, 256);

Answer 4

Put all of your leak detection code in a another, separate DLL. Then make sure that the code you want to check for leaks depends on the DLL. This lets the loader do the work of ensuring that the "leak checking DLL" gets initialized before everything else and also gets unloaded after everything else. Doing this will ensure that your leak checking code runs after all other code has been unloaded (and destructors called).

This is the technique I used when I created Visual Leak Detector, and it seems to work well.