factory.hpp

template<class Interface, typename KeyT = int>
struct Factory
{
    public:
        typedef KeyT                                    Key;
        typedef Interface*                              Type;
        typedef Type (*Creator)();

        bool    define(Key const& key, Creator v)       { return _registry.insert(typename Registry::value_type(key, v)).second; }
        Type    create(Key const& key)
        {
            typename Registry::const_iterator i = _registry.find(key);
            if (i == _registry.end())
                throw std::invalid_argument(std::string(__PRETTY_FUNCTION__) + ": key not registered");
            else
                return i->second();
        }

        template<class Base, class Actual>
        static
        Base*   create_func()                           { return new Actual; }

    private:
        typedef  std::map<Key, Creator> Registry;
        Registry _registry;
};

struct Base
{
    public:
        typedef ::Factory<Base> Factory;
        virtual         ~Base()                                 {}
        virtual int     answer() const = 0;

        static
        Factory::Type   create(Factory::Key const& name)        { return _factory.create(name); }

        template<class Derived>
        static void define(Factory::Key const& name)
        {
            bool new_key = _factory.define(name, &Factory::template create_func<Base, Derived>);
            if (not new_key)
                throw std::logic_error(std::string(__PRETTY_FUNCTION__) + ": name already registered");
        }

    private:
        static Factory _factory;
};
Base::Factory Base::_factory;

struct A: Base
{
    virtual int answer() const { return 42; }
};

int main()
{
    Base::define<A>("A");
    assert(Base::create("A")->answer() == 42);
    return 0;
}