Singletons

Whenever we talk about singletons, people always want to make a
class. One often cited example is some variant of this:

lass CMySingleton
{
public:
   static CMySingleton& Instance()
   {
     static CMySingleton singleton;
     return singleton;
   }

// Other non-static member functions
private:
   CMySingleton() {} // Private constructor
   ~CMySingleton() {}
   CMySingleton(const CMySingleton&); // Prevent
copy-construction
   CMySingleton& operator=(const CMySingleton&); // Prevent assignment
};

My question is why do people get locked into thinking that the
singleton must be a class? The problem with the above is first you
can't control when destruction happens, and second, getting a static
object from a function is actually very expensive. Everytime you call
Instance() the compiler inserts a hidden check to see if the static
object was already initialized. So thats one unneeded branch everytime
you fetch the singleton.

It gets much worse though. Because of thread safety, gcc actually
inserts locking code into the Instance() function, meaning not only
are you doing useless branching, but you also have to grab and release
locks.

Why not free ourselves from the "everything must be objects" mentally
and just use free functions. For example:

namespace singleton {
void init(/*args */);
void shutdown():
//other singleton methods
}

Now I can control when the singleton gets initialized and
destroyed. In addition I can also hide the global state of the
singleton in its cpp file and I get to decide whether its heap
allocated or just placed in global memory.

Your thoughts?

--
      [ See http://www.gotw.ca/resources/clcm.htm for info about ]
      [ comp.lang.c++.moderated. First time posters: Do this! ]