C++实现反射机制

C++本身是不支持反射机制的，而在最近项目中很多地方用到了工厂类，这样就增加了代码中分支语句，降低了代码的可读性，于是就模仿C#中的反射机制，用函数指针自己实现了C++的反射。下面是实现时写的demo介绍。

主要特点有以下几点：

• 用map保存了字符串到动态类生成的函数指针的映射。
• 使用类名注册，根据不同的类名字符串构造成不同的类对象。

代码实例：Singleton类

• 头文件

  #pragma once
  
  template<class T>
  class Singleton
  {
  public:
      using object_type = T;
      struct object_creator
      {
          object_creator() { Singleton<T>::instance(); }
      };
  
      static object_creator creator_object;
  public:
      static object_type* instance()
      {
          static object_type _instance;
          return &_instance;
      }
  };
  template<typename T> typename Singleton<T>::object_creator Singleton<T>::creator_object;

代码实例：ClassFactory类

• 头文件

  #pragma once
  #include "Singleton.h"
  
  #include <map>
  
  class Item;
  
  //定义一个返回值为void* 参数为null的函数指针
  typedef void* (*ItemObject)();
  
  struct ItemObjectClass
  {
      explicit ItemObjectClass(ItemObject item) : itemObject(item) {}
      ItemObject itemObject;
  };
  
  
  //作为所有类的工厂，如有需要某一类型的类的工厂可以继承此类
  class ClassFactory : public Singleton<ClassFactory>
  {
  public:
      ClassFactory();
      ~ClassFactory();
  
      
      //************************************
      // Method:    CreateItem 创建类，
      // FullName:  ClassFactory::CreateItem
      // Access:    public 
      // Returns:   void *
      // Qualifier:
      // Parameter: string className
      //************************************
      void * CreateItem(string className);    // 返回void *减少了代码的耦合
  
      //
      //************************************
      // Method:    RegisterItem
      // FullName:  ClassFactory::RegisterItem
      // Access:    public 
      // Returns:   void
      // Qualifier:
      // Parameter: const string & className 要创建类的类名
      // Parameter: ItemObject item 函数指针，该指针在宏REGISTER_CLASS中被绑定
      //************************************
      void RegisterItem(const string& className, ItemObject item);
  
  private:
      //缓存类名和生成类实例函数指针的map，ItemObject实际上是一个函数指针
      map<string, ItemObjectClass *> objectItems;
  };

• 源文件

  #include "stdafx.h"
  #include "ClassFactory.h"
  
  
  
  ClassFactory::ClassFactory()
  {
  }
  
  
  ClassFactory::~ClassFactory()
  {
      for (auto it : objectItems)
      {
          if (it.second != nullptr)
          {
              delete it.second;
              it.second = nullptr;
          }
      }
      objectItems.clear();
  }
  
  
  //返回void *减少了代码的耦合
  void * ClassFactory::CreateItem(string className)
  {
      ItemObject constructor = nullptr;
  
      if (objectItems.find(className) != objectItems.end())
          constructor = objectItems.find(className)->second->itemObject;
  
      if (constructor == nullptr)
          return nullptr;
  
      // 调用函数指针指向的函数 调用REGISTER_CLASS中宏的绑定函数，也就是运行new className代码
      return (*constructor)();
  }
  
  //ItemObject相当于一个回掉函数
  void ClassFactory::RegisterItem(const string& className, ItemObject item)
  {
      map<string, ItemObjectClass *>::iterator it = objectItems.find(className);
      if (it != objectItems.end())
          objectItems[className]->itemObject = item;
      else
          objectItems.insert(make_pair(className, new ItemObjectClass(item)));
  }

工厂类实例主要时用来生成每个类的实例，该类的优点是，编写完成后，不需要改动，就可以生成想要的类的实例（减少了增加或者删除类时候要修改相应分支的代码）。

代码实例：REGISTERCLASS类  该类是一个宏定义，是为了实现动态类型的创建

• 头文件

  #pragma once
  
  
  //该宏定义实现了一个动态类的创建，
  //   ## 合并操作符 将操作两边的字符合并成一个新的标识符，合并后新的标识符不是字符串
  //   #  构串操作符 它将实参的字符序列（而不是实参代表的值）转换成字符串常量, 转换后是一个字符串
  //   class className##Helper : 如className是FileItem，程序将会生成一个FileItemHelper类。
  //   构造函数 : 调用工厂类的注册函数，实现了类名和生成类实例函数的绑定 
  //   CreatObjFunc函数 : 生成一个类实例   比如className是FileItem,则new FileItem.  返回void *减少了代码的耦合
    
  #define REGISTERCLASS(className) 
  class className##Helper { 
  public: 
      className##Helper() 
      { 
          ClassFactory::instance()->RegisterItem(#className, className##Helper::CreatObjFunc); 
      } 
      static void* CreatObjFunc() 
      { 
          return new className; 
      } 
  }; 
  className##Helper className##helper;
  //定义了一个成员变量，如FileItemHelper类的成员变量 FileItemhelper

上述类型都是为反射动态创建类型准备的类，相当于是工具类，下面就是需要创建的动态类型的实例类介绍。

代码实例：Object类  是整个动态类型的基类，可有可无，在这里添加是为了方便扩展。

• 头文件

  #pragma once
  
  //所有类的基类
  class Object
  {
  public:
      Object();
      virtual ~Object();
  
      const string& GetClassName() const { return className; }
  
  protected:
      string className;
  };

• 源文件

  #include "stdafx.h"
  #include "Object.h"
  
  
  Object::Object()
  {
  }
  
  Object::~Object()
  {
  
  }

代码实例：Item类  所有Item的基类

•  头文件

  #pragma once
  #include "Object.h"
  
  //所有Item的基类
  class Item : public Object
  {
  public:
      Item();
      virtual ~Item();
  
      virtual void Print() = 0;
  
  };

• 源文件

  #include "stdafx.h"
  #include "Item.h"
  
  
  Item::Item()
      : Object()
  {
  }
  
  
  Item::~Item()
  {
  }

　　该类是所有Item类型类的基类，下面将列举FileItem和ConsoleItem作为该类的派生类来具体实现和使用派生类的动态类型生成。

代码实例：FileItem类

•  头文件

  #pragma once
  #include "Item.h"
  
  class FileItem : public Item
  {
  public:
      FileItem();
      ~FileItem();
  
      virtual void Print() override;
  
  };

• 源文件

  #include "stdafx.h"
  #include "FileItem.h"
  
  
  FileItem::FileItem()
      : Item()
  {
      className = "FileItem";
  }
  
  
  FileItem::~FileItem()
  {
  }
  
  void FileItem::Print()
  {
      cout << className << endl;
  }

代码实例：ConsoleItem类

•  头文件

  #pragma once
  #include "Item.h"
  
  class ConsoleItem : public Item
  {
  public:
      ConsoleItem();
      ~ConsoleItem();
  
      virtual void Print() override;
  
  };

• 源文件

  #include "stdafx.h"
  #include "ConsoleItem.h"
  
  
  ConsoleItem::ConsoleItem()
      : Item()
  {
      className = "ConsoleItem";
  }
  
  
  ConsoleItem::~ConsoleItem()
  {
  }
  
  void ConsoleItem::Print()
  {
      cout << className << endl;
  }

 到此为止，使用单例，工厂和函数指针来完成的反射机制已完成，现在就是怎么来使用该反射机制。那么在main函数中将会给出使用实例：

• main函数

  // main.cpp: 定义控制台应用程序的入口点。
  //
  
  #include "stdafx.h"
  
  #include "ClassFactory.h"
  #include "FileItem.h"
  #include "ConsoleItem.h"
  #include "REGISTERCLASS.h"
  
  //类型注册，必须注册才能使用，不注册降不会动态生成需要的类的实例
  REGISTERCLASS(FileItem)
  REGISTERCLASS(ConsoleItem)
  
  
  int main()
  {
      FileItem* fileItem = static_cast<FileItem *>(ClassFactory::instance()->CreateItem("FileItem"));
      fileItem->Print();
      delete fileItem;
  
      ConsoleItem* consoleItem = static_cast<ConsoleItem *>(ClassFactory::instance()->CreateItem("ConsoleItem"));
      consoleItem->Print();
      delete consoleItem;
  
      return 0;
  }

　　该反射机制是每一次CreateItem就会创建一个新的类实例，所有使用完成后，需要我们手动调用delete来释放掉该类的实例。

 上述文件源码：https://download.csdn.net/download/qq123hongli/10405339