Templates and lazy initialization - c++

Question

I have a UIManager that manages a series of classes that inherit from a single UI class. Currently, it works something like this, where the individual UIs are initialized lazily and are stored statically:
class UIManager
{
public:
UIManager(); // Constructor
virtual ~UIManager(); // Destructor
template <typename T>
T *getUI()
{
static T ui(); // Constructs T, stores result in ui when
// getUI<T>() is first called
return &ui;
}
}
Called with:
getUI<NameEntryUI>()->activate();
or
getUI<MenuUI>()->render();
I am considering a design change that would allow me to have more than one player, hence more than one game window, hence more than one UIManager. I want all my constructed ui objects to be cleaned up when the UIManager is deleted (currently, because the ui objects are static, they stick around until the program exits).
How can I rewrite the above to remove the ui objects when UIManager is killed?
======================================
Here is the solution I've implemented. Early results are that it is working well.
Basically, I started with the idea suggested by Potatoswatter, which I liked because it was similar to an approach I had started then aborted because I didn't know about typeid(T). I backported the code to use only C++98 features. The key to the whole thing is typeid(T), which lets you map instantiated interfaces to their type in a consistent manner.
class UIManager
{
typedef map<const char *, UserInterface *> UiMapType;
typedef UiMapType::iterator UiIterator;
map<const char *, UserInterface *> mUis;
public:
UIManager(); // Constructor
virtual ~UIManager() // Destructor
{
// Clear out mUis
for(UiIterator it = mUis.begin(); it != mUis.end(); it++)
delete it->second;
mUis.clear();
}
template <typename T>
T *getUI()
{
static const char *type = typeid(T).name();
T *ui = static_cast<T *>(mUis[type]);
if(!ui)
ui = new T();
mUis[type] = ui;
return ui;
}
}

Answer 1

Currently, you only have storage space allocated for one UI element of each type. It's fundamentally impossible to keep that principle yet have any number of windows.
The quick and dirty solution would be to add a template argument for the window number. If it's a game, and you only have a limited number of players, you can have static storage for some predetermined number of windows.
template <typename T, int N>
T *getUI()
The approach of tying UI identity to the type system is fundamentally flawed, though, and I would recommend a more conventional approach using polymorphism and containers.
One way to identify the objects by type, yet store them dynamically, could look like
class UIManager {
std::map< std::type_index, std::unique_ptr< UIBase > > elements;
template< typename T >
T & GetUI() { // Return reference because null is not an option.
auto & p = elements[ typeid( T ) ];
if ( ! p ) p.reset( new T );
return dynamic_cast< T & >( * p );
}
}
Note that this requires UIBase to have a virtual destructor, or the objects won't be terminated properly when you quit.

Answer 2

Since you clearly need multiple objects per type, let's simply store the objects in a std::map<UIManager const*, T>. To pull out a specific managed object, it is looked up in the map for the corresponding type. The tricky bit is later getting rid of the objects which is handled using a list of function objects:
class UIManager
{
std::vector<std::function<void()>> d_cleaners;
UIManager(UIManager const&) = delete;
void operator=(UIManager const&) = delete;
public:
UIManager();
~UIManager();
template <typename T>
T *getUI() {
static std::map<UIManager const*, T> uis;
typename std::map<UIManager const*, T>::iterator it = uis.find(this);
if (it == uis.end()) {
it = uis.insert(std::make_pair(this, T())).first;
this->d_cleaner.push_back([it, &uis](){ uis.erase(it); });
}
return &(it->second);
}
};
The respective getUI() function stores a map mapping the address of the UIManager, i.e., this, to the corresponding object. If there is no such mapping, a new mapping is inserted. In addition, to make sure objects are cleaned up, a cleaner function is registered with this, simply erase() in the iterator just obtained from the corresponding map. The code is untested but something along those lines should work.