每天一个设计模式之反射+工厂模式 Qt

  • A+
所属分类：IT技术

解决问题

使用工厂模式创建对象时，会通过传入的参数进行if判断，来创建出合适的对象。另外，也引入了实现子类，这样导致在工厂创建时，必须知道子类实现细节，并且，如果再增加子类，会需要修改工厂类，增加if判断。

达到目的

工厂通过传入类名字符串，创建出需要的对象。

代码

DynOBJ.h文件

  1. #ifndef DYNOBJ_H
  2. #define DYNOBJ_H
  4. #include <string>
  5. #include <map>
  6. typedef void* (*Constructor)();//定义一个函数指针void* Constructor()
  8. //该类负责创建一个map，该map负责存储类名字符串和其对应的构造方法，
  9. //并提供注册和根据类名字符串创建对象的方法
  10. class CObjecctFactory{
  11. public:
  12.     static void registerClass(std::string className, Constructor constructor){
  13.         constructors()[className] = constructor;
  14.     }
  16.     static void* createObject(const std::string& className){
  17.         Constructor constructor = NULL;
  18.         if(constructors().find(className) != constructors().end()){
  19.             constructor = constructors().find(className)->second;
  20.         }
  22.         if(!constructor)
  23.         {
  24.             return NULL;
  25.         }
  26.         return (*constructor)();//调用函数指针指向的函数，*即解引用
  27.     }
  28. private:
  29.     //<string,Constructor>:string->动态创建的类的类名，Constructor是构建函数指针
  30.     inline static std::map<std::string, Constructor>& constructors(){
  31.         static std::map<std::string, Constructor> instance;
  32.         return instance;
  33.     }
  34. };
  36. //定义一个宏，在新建类的地方调用，达到注册的目的
  37. #define REG_CLASS(class_name) \
  38. class class_name##Helper{ \
  39. public: \
  40.     class_name##Helper(){ \
  41.         CObjecctFactory::registerClass(#class_name,class_name##Helper::createObjFunc); \
  42.     } \
  43.     static void* createObjFunc(){ \
  44.         return new class_name; \
  45.     } \
  46. }; \
  47. class_name##Helper class_name##helper;
  48. //在这里直接实例化出每个类对应的全局对象helper，
  49. //自动调用helper的构造函数完成类注册
  52. #endif // DYNOBJ_H

该文件提供了注册类和创建对象的公共方法。

SimpleFactoryRefactor.cpp

  1. #include <iostream>
  2. #include <string>
  3. #include "DynOBJ.h"
  5. using namespace std;
  7. class Api{
  8. public:
  9.     virtual void test(string s)=0;
  11. protected:
  12.     Api(){}
  13. };
  15. class ImpleOne:public Api{
  16. public :
  17.     void test(string s){
  18.         cout<<"one is running"<<s;
  19.     }
  20. };
  21. REG_CLASS(ImpleOne)
  23. class ImpleTwo:public Api{
  25. public :
  26.     void test(string s){
  27.         cout<<"two is running"<<s;
  28.     }
  29. };
  30. REG_CLASS(ImpleTwo)//实际使用时，可以在子类定义的末尾使用注册宏
  32. class AutoFactory{
  33. public:
  34.     static Api* createApi(){
  35.         Api* pApi = NULL;
  36.         //可通过配置文件存储的字符串进行自动切换配置
  37.         //当然，如果应用在模块集成中，此处可以通过读取某个文件夹下的所有模块入口类名，
  38.         //在这里进行动态循环创建，再通过统一的接口Api进行无差别访问，不需要知道Api的子类实现
  39.         pApi = static_cast<Api*>(CObjecctFactory::createObject("ImpleOne"));
  40.         return pApi;
  41.     }
  42. };
  44. int main(void)
  45. {
  46.     Api* pApi = AutoFactory::createApi();
  47.     pApi->test(":AutoFactory");
  48.     system("pause");
  49.     return 0;
  50. }

 

Qt大课堂-QtShare

发表评论

您必须登录才能发表评论！