bool InitializeStaticCriticalSection(CCriticalSection * i_pCS)
{
    i_pCS->Initialize();

    return false;
}

bool CCore::DoCreate()
{
    static CCriticalSection CS;
    static bool fCreated = InitializeStaticCriticalSection(&CS);
...

К>class CCore
К>{
К>public:
К>    CCore()
К>    {
К>        DoCreate();
К>    }
К>};

К>CCore& core()
К>{
К>    static CCore obj;
К>    return obj;
К>}
К>

if(!CCore::DoCreate())
{
    return false;
}

// здесь обращаемся к членам CCore, которые создаются и инициализируются в CCore::DoCreate.

static long volatile flag = 0;
if(!flag && !InterlockedExchange(&flag,1))
{
    // flag был 0, стал 1
    // начинаем инициализацию
}

S>Информация полезная, но не хотелось бы привязывать проект (и без того мутный) к таким тонкостям .

class CSingleton {
public:
    static CSingleton& Get()
    {
        static CSingleton seed;
        return seed;
    }
    
    void Method() { assert( is_created ); }

private:
    bool is_created;

    CSingleton() : is_created( true ) {}
    ~CSingleton() { is_created = false; }
};

static class CA {
public:
    ~CA() { CSingleton::Get().Method(); }  // Тут-то всё и гавкнется... :(
} a;

static class CB {
public:
    CB() {  CSingleton::Get().Method(); }
} b;

К>static long volatile flag = 0;
К>if(!flag && !InterlockedExchange(&flag,1))
К>{
К>    // flag был 0, стал 1
К>    // начинаем инициализацию
К>}
К>

bool CCore::DoCreate()
{
    static long volatile fCreating = 0;

    if(!fCreating && !InterlockedExchange(&fCreating, 1))
    {
        if(!Create()) // Construct all core objects.
        {
            fCreating = 3; // To set free pending threads (3 - return false).
            return false;
        }

        fCreating = 2; // To set free pending threads (2 - return true).
    }

    while(1 == fCreating) // Wait until Create() has finished (pending).
    {
        Sleep(200);
    }

    if(3 == fCreating)
    {
        return false;
    }

    return true;
}

static const std::string& GetName()
{
    static std::string name = "Йо-Мойо!!!";
    return name;
}
static class CA {
public:
    ~CA() { GetName(); }
} ca;

J>Изв,

#include "StreamInitializer.h"
#include "A.h"

// stream уже инициализирован потому как StreamInitializer.h включен выше.
// класс A может создавать объекты Stream
A a;

int main()
{
return 0;
}