Re: Confused about a thread-safe singleton example.

I have a C++-specific question about thread-safe singleton instances.
 There's a trivial example here:

http://www.bombaydigital.com/arenared/2005/10/25/1

That goes like this, very simple and straightforward:

static Mutex mutex; static TheClass *instance;

static TheClass * getInstance () { MutexLocker lock(mutex); if
(!instance) instance = new TheClass(); return instance; }

The example then goes on to talk about how double-check
locking is broken, etc. My question is pretty much this: Is
C++ static initialization thread-safe? If not, then how does
the above example safely use "mutex"? If so, then what is
wrong with this:

static TheClass instance; // not a pointer

static TheClass * getInstance () { return &instance; // it's
correctly initialized? }

The reason I ask is I almost never see it done like that, I
always see blog entries and articles that say the same thing
"store instance in a pointer, use a mutex to protect, and
p.s. double-checked locking is broken". It seems like doing
it lock-free is made out to be a hard problem, so *if*
having a static instance works (but I don't know if it does,
that's my question), then why doesn't anybody ever suggest
it?