class StreamInitializer {
  public:
    StreamInitializer ();
    ~StreamInitializer ();
} initializer; //Note object here in the header.

static class StreamInitializer {
  public:
    StreamInitializer ();
    ~StreamInitializer ();
} initializer; //Note object here in the header.

//Module1.cpp
static std::string folder = "..\\DATA";

//Module2.cpp
static std::string path = folder + "\\log.txt";

//Module1.cpp
std::string& folder()
{
    static std::string value = "..\\DATA";
    return value;
} 

//Module2.cpp
std::string& path()
{
    static value = folder() + "\\log.txt";
    return value;
}

extern int x, y, z, t;
.....

// компилятор с линкером разрулят, что y зависит от x
int x = printf("initialize x\n")+rand();
.....
int y = printf("initialize y\n")+x;

// кольцевая зависимость
int z = printf("initialize z\n")+t;
.....
int t = printf("initialize t\n")+z;

static CClass MyObject;

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

    CS.Lock();

    if(!fCreated)
    {
        fCreated = true; // To prevent subsequent attempts to create.

        if(!Create())
        {
            CS.Unlock();
            return false;
        }
    }

    CS.Unlock();

    return true;
}

const bool isCoreCreated = CCore::DoCreate();

S>bool CCore::DoCreate()
S>{
    static long fCreated = 0;
    if( !fCreated ) // первая проверка - дешёвая (и плевать на гонки)
        if( !atomic_test_and_set(&fCreate,0,1) ) // вторая - строгая
            Create();
S>}
S>

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

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

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;
}