Understanding Meyers' Singleton in C++: Why Static Local Variables Matter

When asked why C++ singleton patterns should not rely solely on global static variables and functions, the answer lies in the advantages of using a static local variable inside a getInstance() function, commonly called Meyers' Singleton.

The classic implementation looks like this:

class Singleton {
public:
    static Singleton& getInstance() {
        static Singleton inst;
        return inst;
    }
    Singleton(const Singleton&) = delete;
    Singleton& operator=(const Singleton&) = delete;
    // other member functions
private:
    Singleton() { /* ... */ }
    // other data members
};

This form was popularized by Scott Meyers and relies on C++11's guarantee that function‑local static variables are initialized in a thread‑safe manner, eliminating the need for explicit locks.

Using this pattern avoids the static‑initialization‑order fiasco: while the compiler can order static objects within a single translation unit, it cannot guarantee the order across multiple files. If two singleton objects in different files depend on each other, one may be used before it is constructed, leading to undefined behavior.

Because the instance is created the first time getInstance() is called, the initialization is deferred until it is actually needed, ensuring the object is fully constructed before any use.

The approach also works well with inheritance; a derived class can safely inherit from the singleton base without sharing static state unintentionally.

Note that this technique requires C++11 or later, as earlier standards do not guarantee thread‑safe initialization of static locals.

In summary, Meyers' Singleton provides a simple, lazy‑initialized, thread‑safe singleton implementation that solves static‑initialization‑order problems and works correctly with inheritance, making it a recommended idiom for most C++ projects.