关于工厂模式和类型登记表

需求：在实际应用中，我经常会遇到这样一种情况，在底层的某个接口中，提供一个传入一个父类指针，又向上层提供一个类型可扩展的方式，使得上层可以自定义父类的实现，但与此同时，又想封装对这个类的所有使用，使用户只能定义这个类的行为，而不能自己使用这个类。

 

一下为实现这种模式的一种方法： 带有登记表的工厂模式

 

class TypeBase

{

      virtual void do_something() = 0;

};

 

class CreatorBase

{

public:

      virtual TypeBase* create() = 0;

};

 

template <class type_impl>

class Creator : public CreatorBase

{

public:

      virtual TypeBase* create()

      {

             return new type_impl;

      }

};

 

template <class type_base>

class RegisterFactory

{

public:

      static RegisterFactory* instance()

      {

            {

                  thread::Lock lock;

                  if(!factory)

                       factory = new RegisterFactory<type_base>;

            }

            return factory;

      }

 

      void register(std::string name, CreatorBase* creator)

      {

            register_table_.insert(std::make_pair(name, creator));

      }

 

      type_base* create(std::string name)

      {

            register_table_t::iterator it = register_table_.find(name);

            if(it != register_table_t.end())

                 return it->second->create();

      }

 

#define co_register(type) /

{/

      Creator<type> creator;/

      register("#type#", creator);/

}

 

#define co_create(type)/

{/

      create("#type#");/

}

 

private:

      typedef std::map<std::string, CreatorBase*> register_table_t;

 

      RegisterFactory() {}

      ~RegisterFactory() {}

 

      static RegisterFactory* factory_;

      register_table_t register_table_;

};