|- boost::singleton| : can be used to create Singletons with synchronized initialization.
I've just become aware that g++ already provides synchronised initialisation of function-scope statics, unless you specify -fno-threadsafe-statics, and that if N2444 is accepted this will be the required behaviour in C++0x. With this functionality, there is no need for the proposed boost::singleton class since Meyer's singleton suffices: class MyClass { MyClass() {...}; public: static MyClass& instance() { static MyClass i; return i; } }; What do people feel about implementing functionality in a Boost library that will soon become unnecessary? I previously suggested that we could have a safe_static<T> template or macro, but I'm now wondering if we really want unsafe_static<T> to get the opposite effect! Neither is simple to implement; a macro like this perhaps: #define UNSAFE_STATIC(T,t) // The compiler would add unwanted locking if we just wrote 'static T t'. // So we declare uninitialised memory to hold t, and code our own initialisation test. static char _#t#_buf [sizeof(T)]; // worry about alignment static bool _#t#_init = false; if (!_#t#_init) { new (&_#t#_buf[0]) T; _#t#_init = true; } T& t = *(???_cast<T*>(&_#t#_buf[0])); Tobias, since I wrote my review I've seen a few others also suggesting that you should decouple the thread-safety features (e.g. the synchronous access in your mutex_singleton) from the singleton itself. I would be interested to know whether you would consider doing this in a revision of your submission, or whether you want to stick to your existing implementation. Regards, Phil.