typedef class _CONTAINER{
} CCONTAINER;
// ниже
static CCONTAINER container;

A>typedef class _CONTAINER{
A>} CCONTAINER;
A>// ниже
A>static CCONTAINER container;
A>

// В файле file1.cpp
Foo foo;
Foo* f = &foo;
// В файле file2.cpp
extern Foo* f;
Foo f1(*f); // Используется конструктор копий

Если бы все это находилось в одном исходном файле, ситуация была бы нормальной. Со строкой Fоо*
f = &foo; проблем не возникает, поскольку глобальные объекты одного исходного файла заведомо
(хе-хе) инициализируются в порядке их определения. Другими словами, когда программа доберется до
этой строки, объект foo уже будет сконструирован. Тем не менее, никто не гарантирует, что
глобальные объекты в файле file1.cpp будут инициализированы раньше глобальных объектов в файле
file2.срр. Если file2.cpp будет обрабатываться первым, f оказывается равным 0 (NULL на большинстве
компьютеров), и при попытке получить по нему объект ваша программа героически умрет.

Лучший выход — сделать так, чтобы программа не рассчитывала на конкретный порядок
инициализации файлов .срр. Для этого используется стандартный прием — в заголовочном файле .h
определяется глобальный объект со статической переменной, содержащей количество
инициализированных файлов .срр. При переходе от 0 к 1 вызывается функция, которая инициализирует
все глобальные объекты библиотечного файла .срр. При переходе от 1 к 0 все объекты этого файла
уничтожаются.

// В файле Library.h
class Library {
private:
static int count;
static void OpenLibrary();
static void CloseLibrary();
public:
Library();
~Library();
};
static Library LibraryDummy;
inline Library::Library()
{
if (count++ == 0)
OpenLibrary();
}
inline Library::~Library()
{
if (--count == 0)
CloseLibrary();
}
// В Library.cpp
int Library::count = 0; // Делается перед выполнением вычислений
int aGlobal;
40
Foo* aGlobalFoo;
void Library::OpenLibrary()
{
aGlobal = 17;
aGlobalFoo = new Foo;
}
void Library::CloseLibrary()
{
aGlobal = 0;
delete aGlobalFoo;
aGlobalFoo = NULL;
}

К этому нужно привыкнуть. А происходит следующее: файл .h компилируется со множеством других
файлов .срр, один из которых — Library.cpp. Порядок инициализации глобальных объектов,
встречающихся в этих файлах, предсказать невозможно. Тем не менее, каждый из них будет иметь
свою статическую копию LibraryDummy. При каждой инициализации файла .срр, в который включен
файл Library.h, конструктор LibraryDummy увеличивает счетчик. При выходе из main() или при
вызове exit() файлы .срр уничтожают глобальные объекты и уменьшают счетчик в деструкторе
LibraryDummy. Конструктор и деструктор гарантируют, что OpenLibrary() и CloseLibrary()
будут вызваны ровно один раз.

A>typedef class _CONTAINER{
A>} CCONTAINER;
A>// ниже
A>static CCONTAINER container;
A>

#ifndef ...
#define ...
#endif

#ifndef _CLASSA_H_
#define _CALSSA_H_
...

typedef class CAbra
{
public:
    CAbra(){
        printf("Constructor\n");
    }
    virtual ~CAbra(){}
}ABRA;
#endif

#ifndef _TEMP1_H_
#define _TEMP1_H_

#include "abra.h"

extern ABRA abra_class;

#endif

#include "temp1.h"
 static CAbra abra_class;

    /** Initialization chain */
    class Initializer {
    public:
        static void Init();
        static void Terminate();

    protected:
        Initializer();
        virtual void OnInit() throw() {};
        virtual void OnTerminate() throw() {};

    private:
        Initializer* next;
    };

    //////////////////////////////////////////////////////////////////////////
    // initializer routine
    Initializer* moduleInitializer=0;

    Initializer::Initializer() : next(moduleInitializer) {
        moduleInitializer=this;
    }

    void Initializer::Init() {
        Initializer* i=moduleInitializer;
        while (i) {
            i->OnInit();
            i=i->next;
        }
    }

    void Initializer::Terminate() {
        Initializer* i=moduleInitializer;
        while (i) {
            i->OnTerminate();
            i=i->next;
        }
    }

struct GlobalInitializer {
    GlobalInitializer() { Initializer::Init(); }
    ~GlobalInitializer() { Initializer::Terminate(); }
};

int main() {
    GlobalInitializer globalInitializer;
// start your program here
    
}

static struct : public TargetClass, public Initializer {

    [...]

    virtual void OnInit() { 
    // do some initialization...
    // use another static objects from different units
    }

    [...]

} myStaticExemplarOfTargetClass;