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.

>I want the ability to guarantee that the vector is emptied and the class
>pointers are deleted (hence calling the class' destructors).
Wrap the vector in a class and have that destructor handle the release of your pointers. Or you could use smart pointers.

I'm not sure how much of a problem this is. I'm far from being an expert, but I believe your static data members will be destroyed after main(). At that time, the vector contents class destructors will be called regardless, ensuring proper deallocation. Assuming the deallocation is being properly coded inside the destructor all will be ok... and even better if you implement smart pointers.

My shaky 2 cents

>> 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.

Quote:

---

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

---

You mean dllMain?

The vector holds pointers to a specific class type. I'd assumed that delete'ing the pointer would call the appropriate destructor. I put a message in the destructor and if you specifically delete each element in the vector, the destructor appears to be called OK. But if you don't specifically call the destructors (leaving the DLL to clean-up), the class destructor isn't called.

I don't want to have to instantiate the class, it only contains static data and static functions. It's just a convenience to wrap the functions in a class in the first place, to logically group them.

I'm not sure what wrapping the (static) class in another class is going to achieve?

I'll have a look at smart pointers.

Are you sure isn't simply the output not reaching you? What sort of message?
Try logging the destructor action to a file.

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.

Wait. You are right of course. I was assuming he was noticing that behavior by calling clear on the vector.

Hmm... Daved?
... but wouldn't exiting the application call the destructors after main()?

Regardless, making the class containing the statics a singleton seems the natural thing to do.

>> 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.

Quote:

---

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.