struct data_t
{
  ...
} data = {0};

long volatile initialized = FALSE;

void init()
{
  if (!initialized)
    return;
  data_t local_data;
  /* инициализация local_data */
  ...
  if (::InterlockedExchange(&initialized, TRUE))
    memcpy(&data, local_data, sizeof(data_t);
}

AG>struct data_t
AG>{
AG>  ...
AG>} data = {0};

AG>long volatile initialized = FALSE;

AG>void init()
AG>{
AG>  if (!initialized)
AG>    return;
AG>  data_t local_data;
AG>  /* инициализация local_data */
AG>  ...
AG>  if (::InterlockedExchange(&initialized, TRUE))
AG>    memcpy(&data, local_data, sizeof(data_t);
AG>}
AG>

struct data_t
{
  static data_t* getInstance()
  {
    lock(); // например с помощью мьютекса
    static data_t* instance = new data_t;
    unlock();
    return instance;
  }
};

struct data_t
{
  static data_t* getInstance()
  {
    QMutexLocker locker(&mutex);
    static data_t* instance = new data_t;
    return instance;
  }
  static QMutex mutex;
};

struct S { S() }

S s1;

struct X
{
  static S s2;
}

S X::s2;

S s3;

struct S1
{
  int i;
} s2 = {1};

struct S2
{
  int i;
  S2() : i(1) {}
} s2 = 1;

enum InitStatus { NotSet, InProgress, Complete };

template<class Fun>
void do_once(long volatile* status, Fun fun)
{
    switch( InterlockedCompareExchange(status, InProgress, NotSet) )
    {
    case NotSet:
        fun();
        InterlockedExchange(status, Complete);
        return;
    case InProgress:
        while( InterlockedCompareExchange(status, InProgress, InProgress) != Complete )
            Sleep();
        return;
    case Complete:
        return;
    default:
        assert(false);
    }
}

struct StaticCS // POD
{
    long volatile status;
    CRITICAL_SECTION cs;
    
    void init()
    {
        do_once(&status, boost::bind(InitializeCriticalSection, &cs));
    }
    
    void enter()
    {
        init();
        EnterCriticalSection(&cs);
    }
    void leave()
    {
        assert(status==Complete);
        LeaveCriticalSection(&cs);
    }
};

struct T{
  static T& instance() {
    static T t;
    return t;
  }
};

struct T_init {
  T_init() { T::instance(); }
} const t_init;