Thread: C++ static destructor

Before I get flamed too badly, yes I know there isn't a C++ static destructor.

What I'm after is a technique to clean-up after a class that consists entirely of static member functions and static data. The class maintains a vector of class pointers in its private area. I want the ability to guarantee that the vector is emptied and the class pointers are deleted (hence calling the class' destructors).

The class is actually in a Windows DLL, so I guess there is a function that is called when a DLL is unloaded? If so, I could call a static pseudo-destructor of my own design to clean-up?

I know the memory would be free'd anyway when the DLL unloads, but I wanted a more elegant solution.

I was toying with the idea of a singleton model, but the class is really a wrapper for a whole set of utility functions and I think a singleton model is probably overboard.

>> the vector contents class destructors will be called regardless, ensuring proper deallocation.
If the vector is holding raw pointers, the "destructor" of a raw pointer does nothing and does not properly destroy what it points to. Use of ptr_vector from Boost, or using a vector of shared_ptrs, or wrapping the vector in a class that does the deletion for you (which is exactly what ptr_vector does) are really the best bets.

I do believe there might be a function called when unloading the dll that might also be helpful, but I'm not sure.

Instead of using all static functions, you can make that class a singleton. If you can ensure that the singleton's destructor is called, then in that destructor you can clean up your pointers. You're not actually wrapping your "static" class in another class, you are just changing your static class to clean itself up.

>> Are you sure isn't simply the output not reaching you? What sort of message?
The destructors won't be called if you don't delete the pointers. SKeane's observed behavior is consistent with what is supposed to happen.

>> but wouldn't exiting the application call the destructors after main()?
Which destructors? It will call the destructors for static objects. If the vector is a static member of the class, the vector destructor will be called after main. It will not call the destructor for objects allocated with new, so the pointers inside the vector will not have the destructors of the objects they point to called automatically.

Originally Posted by Daved

Instead of using all static functions, you can make that class a singleton. If you can ensure that the singleton's destructor is called, then in that destructor you can clean up your pointers. You're not actually wrapping your "static" class in another class, you are just changing your static class to clean itself up.

Change all the functions to non-static and declare an object of that class. They will be accessed as normal, except with ObjectName.member instead of ClassName.member, but you can easily just change the names so that it works the same. Then of course use the destructor to do your clean up.

Thanks for the advice. I really should go down the singleton route, but here's what I finally did.

The DLL exports a whole class (the interface). This class' destructor calls a static "pseudo" destructor for the class with all static functions. The class with all static functions uses lazy initialization to load its static data table (a vector of pointers to a class). The class with all static functions has a clean-up routine, which is its "pseudo" destructor. Thus everything is cleaned up. If it weren't for the "outer" class being in a position to call the clean-up routine, I would have invested a bit more energy in making the all static functions class a singleton.