Object Factory and pre-main registering of classes

Hi,

I am trying to create an object factory, AFactory, that allows new
object types (of base class A) to be added without changing the factory.
 The factory is designed so that each class registers itself with the
factory by passing an object name and a pointer to a function that
creates that particular object type. I am trying to get the classes to
register themselves before the main program executes. The behavior I am
getting is the following (confirmed with both g++ and MS Visual Studio).

1. If I compile and link all files simultaneously

    g++ *.cpp

the code works correctly (no reverse dependency)

2. If I compile all files separately and link all object files

       g++ -c *.cpp
       g++ *.o

the code works correctly (no reverse dependency).

3. If I compile files separately, link the factory and related classes
into a library and then link the main routine with the library

       g++ -c A*.cpp
       ar rvs liba.a A*.o
       g++ main.cpp -L. -la

the classes do not register themselves before the main function. A
workaround I found was to put the following in AFactory::GetInstance()
function

  // FIXME: This forces the maps to register. There should be some way
  // to force the registration without creating this reverse dependency.
  if (m_factory.m_callback.empty())
  {
     CreateCallBack fnc;
     fnc = AType1::CreateA;
     // Add all : fnc = ATypeX::CreateA;
  }

I don't want to do this because it creates a reverse dependency that
requires modification of the factory to add a new class.

Is there any way to get this to work and still use libraries? I need
the factory code to be in a library for the project I am working on.

Thanks,
John

============= A.hpp ========================
#ifndef AHPP_
#define AHPP_

#include <string>

   class A
   {
   public:

      /// Default constructor
      A() {}

      /// Destructor
      virtual ~A() {}

      virtual std::string GetName() const = 0;
   };
#endif

============= AType1.hpp ========================

#ifndef ATYPE1HPP_
#define ATYPE1HPP_

#include "A.hpp"

   class AType1 : public A
   {
   private:
   protected:
      static const std::string m_name;

      static const bool m_isRegistered;

   public:
      AType1() : A() {}

      virtual ~AType1() {}

      static A* CreateA() { return new AType1; }

      std::string GetName() const { return m_name; }
   };
#endif

============= AType1.cpp ========================
#include "AType1.hpp"
#include "AFactory.hpp"

// Set the class name. Make sure it matches what is registered below.
const std::string AType1::m_name = std::string("AType1");

// Register the name and instantiation function with the factory
const bool AType1::m_isRegistered = AFactory::GetFactory().RegisterA(
   "AType1", AType1::CreateA);

============= AFactory.hpp ========================
#ifndef AFACTORYHPP_
#define AFACTORYHPP_

// Only need this when compiling to a library
#include "A.hpp"

#include <string>
#include <map>

   class AFactory
   {
      public:
         /// Get the single instance
         static AFactory& GetFactory();

         typedef A* (*CreateCallBack) ();

      private:
         AFactory() {}
         ~AFactory() {}

         AFactory(const AFactory&) {}
         AFactory& operator=(const AFactory& obj) { return *this; }

         typedef std::map< std::string, CreateCallBack > CallBackMap;
         CallBackMap m_callback;

      public:

         bool RegisterA(std::string name, CreateCallBack CreateFunction)
         {
            return m_callback.insert(CallBackMap::value_type(name,
CreateFunction)).second;
         }

         A* CreateA(std::string name)
         {
            // find the callback pointer
            CallBackMap::const_iterator mpos = m_callback.find(name);

            if ( mpos == m_callback.end() )
               return 0;
            else
               return (mpos->second());
        }
   };

#endif

============= AFactory.cpp ========================

#include "AFactory.hpp"

// ** Add all A types
#include "AType1.hpp"

#include <algorithm>
#include <iostream>

AFactory& AFactory::GetFactory()
{
   static AFactory m_factory;

   // FIXME: This forces the maps to register. There should be some
   // way to force the registration without creating this reverse
   // dependency. We only need these lines when using a library.
   if (m_factory.m_callback.empty())
   {
      CreateCallBack fnc;
      fnc = AType1::CreateA;
      // Add all : fnc = ATypeX::CreateA;
   }

   return m_factory;
}

============= main.cpp ========================
#include "AFactory.hpp"
#include "A.hpp"

#include <iostream>

int main()
{

   A* a = AFactory::GetFactory().CreateA("AType1");

   if (a)
      std::cout << a->GetName() << "\n";
   else
      std::cout << a << "\n";

   return 0;
}