Vor einiger Zeit habe ich die Möglichkeit von statischen Initialisierungsfunktionen über statische Variablen nachgeschlagen:

// SomeClass.h
class SomeClass {
public:
    SomeClass();
    ~SomeClass();
private:
    static bool initialize();
    static const bool INITIALIZED;
};

// SomeClass.cpp
const bool SomeClass::INITIALIZED(initialize());

SomeClass::SomeClass() {}
SomeClass::~SomeClass() {}

bool SomeClass::initialize() {
    // Do static stuff
    return true;
}

Bei dieser Methode kommen mir allerdings Bedenken, wenn meine initialize()-Methode auf statischen Inhalt von anderen Klassen zugreifen muss. Wie kann ich z.B. sicher sein, dass eine öffentliche, statische map in einer anderen Klasse zum Initialisierungszeitpunkt dieser Klasse bereits initialisiert bzw. konstruiert ist ist?

Danke für einen kurzen Tipp und beste Grüsse
Kessi

class MyClass
{
    public:
        static std::map<X,Y>& GetMap()
        {
            static std::map<X,Y> Map;
            return Map;
        }
};

Hier ist garantiert, dass die Variable Map beim ersten Aufruf der Methode (und nur dann) initialisiert wird. Dadurch hast du den zusätzlichen Vorteil, dass keine Konstruktion durchgeführt wird, wenn du die Funktion nie aufrufst.

Das fühlt sich ja fast schon wie ein sprach-inhärentes Singleton-Pattern an?

Ein anderes Problem stellt sich jedoch bei der Zerstörung, genauer gesagt, wenn beim Aufräumen Abhängigkeiten zwischen verschiedenen Klassen bestehen. Hier kommt das Meyers-Singleton relativ schnell an seine Grenzen. Andrei Alexandrescu zeigt in seinem Buch "Modern C++ Design" einige Implementierungen auf, die auch dieses Problem bewältigen können.