TObject *GetStaticObject()
{
static TObject obj;
    return &obj;
}

class TStaticIniter
{
public:
    TStaticIniter(){GetStaticObject();}
};
static TStaticIniter static_object_initer;

/**********************************************
        File A.h
**********************************************/

#include <iostream>
#include <vector>
#include <string>
using namespace std;

class A
{
public:
    A(const string& str);
    static bool HaveString(const string& str);
protected:
    typedef vector<string> str_vector;
    static str_vector& GetVector();
};

/**********************************************
        File A.cpp
**********************************************/

#include "A.h"
#include <algorithm>

A::A(const string& str)
{
    GetVector().push_back(str);
}
bool A::HaveString(const string& str)
{
    str_vector& v = GetVector();
    return find(v.begin(), v.end(), str) == v.end() ? false:true;
}

A::str_vector& A::GetVector()
{
    static str_vector tmp;
    return tmp;
}

/**********************************************
        File B.h
**********************************************/

#include "A.h"

class B
{
static A a;
public:
    void UseStaticField();
};

/**********************************************
        File B.cpp
**********************************************/

#include "B.h"

A B::a("class B");

void B::UseStaticField()
{
    size_t size = sizeof(a);
}

/**********************************************
        File main.cpp
**********************************************/

#include "A.h"
#include "B.h"
int main(void)
{
    const char* str = "class B";
    cerr<< "string \""<<str<< (A::HaveString(str)? "\" ":" not ")<<"available in list"<<endl;
    B().UseStaticField();
    cerr<< "string \""<<str<< (A::HaveString(str)? "\" ":" not ")<<"available in list"<<endl;
    return 0;
}

string "class B" available in list
string "class B" available in list

string "class B" not available in list
string "class B" available in list

#include "A.h"
int main(void)
{
    const char* str = "class B";
    cerr<< "string \""<<str<< (A::HaveString(str)? "\" ":" not ")<<"available in list"<<endl;
    return 0;
}

// factory.h
...
///////////////////////////////////////////////////////////////////////////////
//    Вспомогательные макросы
//
#define DECLARE_FACTORY(D, T) \
    friend class Factory<##D, ##T>; 

//    полный аналог Init_Lib [3rd]
#define ENSURE_CREATE(D, T) \
    static Factory<##D, ##T> factory_of_##D(#D); 
...

// sample.h
#ifndef sample_h
#define sample_h

class Base
{
public:
    virtual ~Base() {}

    virtual void func() const = 0;
};

class Der1 : public Base
{
    Der1() {} 
public:
    void func() const
    {
        std::cout << "Der1::func\n";
    }

    DECLARE_FACTORY(Der1, Base)
};
ENSURE_CREATE(Der1, Base) 


class Der2 : public Base
{
    Der2() {} 
public:
    void func() const
    {
        std::cout << "Der2::func\n";
    }
    
    DECLARE_FACTORY(Der2, Base)
};
ENSURE_CREATE(Der2, Base)

#endif

// test.cpp
// пример использования
#include <iostream>
#include <memory>

#include "factory.h"
#include "sample.h"

// теперь factory_of_Der1, factory_of_Der2 попадает в каждую единицу трансляции
// поэтому теперь авторегистрация гарантируется:)
//
std::auto_ptr<Base> guard_der1(Class<Base>::instance().create("Der1"));
std::auto_ptr<Base> guard_der2(Class<Base>::instance().create("Der2"));

void test(Base *ptr)
{
    if( !ptr ) 
    {
        std::cout << "error: no allocated\n";
        return;
    }
    ptr->func();
}

int main(void)
{
    test(guard_der1.get());
    test(guard_der2.get());

    return 0;
}

// MyMakeFunction() - производящая функция

extern "C" void _dummy(void) // подойдёт любой способ
{
  MyMakeFunction();
}

// hdr.h
class A
{
public:
   static A a;
};

// hdr.cpp
A A::a;

// main.cpp
#include "hdr.h"

// так вот здесь никаких гарантий относительно того, что а будет инициализирована
// именно так была поставлена проблема.
A test = A::a;

int main()
{
   A b = A::a;
   return 0;
}

АШ>// hdr.h
АШ>class A
АШ>{
АШ>public:

[ccode]
      A &getA()                
      {

      }

A test = A::getA();

ГВ>Вообще — что-то загадочное. Попробуй а) объявить производящую функцию экспортируемой или б) сделать external-linkage функцию, в которую поместить вызов своей производящей функции (масло масляное, но уж шаманить — так шаманить).

ГВ>// MyMakeFunction() - производящая функция

ГВ>extern "C" void _dummy(void) // подойдёт любой способ
ГВ>{
ГВ>  MyMakeFunction();
ГВ>}

ГВ>

/**********************************************         
    File A.h 
**********************************************/  
#ifndef A_H
#define A_H
#pragma warning(disable: 4786)
#include <iostream> 
#include <map> 
#include <string> 
using namespace std;  

typedef void* (__cdecl *creator_t) ();

class A 
{ 

public:     
    A(const string& str, creator_t fCrt);     
    static void GetInstanceByName(const string& str); 
protected:     
    typedef map<string, creator_t> type_map;     
    static type_map& GetMap(); 
};    

#endif

/**********************************************         
    File A.cpp 
**********************************************/  
#include <algorithm>  
#include "A.h" 

A::A(const string& str, creator_t fCrt) 
{     
    GetMap()[str] = fCrt;
}

void A::GetInstanceByName(const string& str) 
{     
    type_map& v = GetMap();     
    if(v.find(str) != v.end())
        v[str]();
} 

A::type_map& A::GetMap() 
{     
    static type_map tmp;     
    return tmp; 
}

/**********************************************         
    File B.h 
**********************************************/  
#ifndef B_H
#define B_H

#include "A.h"  

class B 
{ 
    public:     
    B();
    protected:
    /*    static A a;
        static B* CreateB();*/
};    

#endif

/**********************************************         
    File B.cpp 
**********************************************/  
#include "B.h"  
// множество перепробованных комбинаций  :) 
extern B* CreateB()
{
    return new B();
}

extern A a("class B", (creator_t) CreateB);  

/*extern "C" B* CreateB()
{
    return new B();
}

extern "C" A a("class B", (creator_t) CreateB);  
*/

/*B* B::CreateB()
{
    return new B();
}

A B::a("class B", (creator_t) B::CreateB);
*/

B::B()
{
    cerr<<"B created"<<endl;
}

/**********************************************         
    File main.cpp 
**********************************************/  
#include "A.h" 
//#include "B.h" 

int main(void) 
{     
    const char* str = "class B";     
        //B b;
    A::GetInstanceByName(str);// не проходит B::B() пока не разкоментирую предидущую строку, тогда два раза конструктор вызывается и конструктор класса А тоже проходит
    return 0; 
}

extern A a("class B", (creator_t) CreateB);