怎么利用C++实现一个反射类

这篇文章主要讲解了“怎么利用c++实现一个反射类”，文中的讲解内容简单清晰，易于学习与理解，下面请大家跟着小编的思路慢慢深入，一起来研究和学习“怎么利用C++实现一个反射类”吧！

代码环境为vscode + CMake + GCC 8.1.0

首先，如何才能做到给我一个名字我就能拿到这个对象的这个值，也是比较难的一个地方，方法如下

#define OFFSET(className,fieldName) (size_t)&(((className*)0)->fieldName)

这个能够得到该成员变量与该对象的偏移量，之后根据这个偏移量来获取成员的值

正题开始

首先这个反射类应该只有一个，要不然反射就会变得很混乱，这一个反射对象，那里一个反射对象。所以应该将该反射类变为一个单例。全局内只允许出现一个。单例类如下：

Singleton.h

#pragma once#include "Singleton.h"#ifndef _SINGLETON_#define _SINGLETON_#include "Util.h"NAME_SPACE_START(myUtil)//单例模式template<typename T>class Singleton{public:    static T* Instance(){        if(m_instance==nullptr){            m_instance = new T();        }        return m_instance;    }private:    Singleton();    Singleton(const Singleton<T>&);    ~Singleton();    Singleton<T>& operator=(const Singleton<T>&);private:    static T* m_instance;};template<typename T>T* Singleton<T>::m_instance=nullptr;#define SINGLETON_DECLARE(className)                    \        friend class Singleton<className>;              \        className(){};                                  \        className(const className&){};                  \        ~className(){};                                 \        className& operator=(const className&);NAME_SPACE_END()#endif //!_SINGLETON_

我在这个头文件中写了一个单例声明SINGLETON_DECLARE，只要将这个声明放到私有部分就行了，这个类就变为一个单例类了。

反射类

如何才能做到反射呢，应该在这个反射类中保存注册表，传入了对应的类名，返回对应的信息，然后使用基类实现对应的方法即可。代码如下：

Reflex.h

#pragma once#include "Util.h"#include <cstdint>#include <vadefs.h>#include <vector>#include <functional>#ifndef _REFLEX_#define _REFLEX_NAME_SPACE_START(myUtil)#include "Singleton.h"#include <map>#include <string>//因为编译器不支持类模板和实现分开写，所以放到一起了class Field;class Reflex;class RObject{public:    RObject(){}    virtual ~RObject(){}    std::string _className;    template<typename T>    T get(const std::string& fieldName);    template<typename T>    void set(const std::string& fieldName, const T& fieldValue);    void Call(const std::string& methodName);    template<typename T,typename... Args>    T Call(const std::string& methodName, Args... args);};typedef RObject* (*construct)(void);//使用方法,使用REGISTER_REFLEX注册，然后直接使用createClass即可class Reflex{    SINGLETON_DECLARE(Reflex)public:    void ReflexRegister();    RObject* createClass(const std::string& className);    void RegisterClass(const std::string& className, construct constructMethod);    void RegisterField(const std::string& className, const std::string& FieldName, const std::string& FieldType, const size_t& offset);    void RegisterMethod(const std::string& className, const std::string& methodName, const uintptr_t& lpMethod);    template<typename T>    T getClassField(void* originPos, const std::string& className, const std::string& fieldName);    template<typename T>    void setClassField(void* originPos, const std::string& className, const std::string& fieldName, const T& fieldValue);    uintptr_t getClaSSMethod(const std::string& className, const std::string& methodName);private:    std::map<std::string, construct> m_classMap;    std::map<std::string, std::map<std::string, Field>> m_fieldMap;    std::map<std::string, std::map<std::string, uintptr_t>> m_methodMap;};//仅仅用来在reflex中注册使用class RegisterClass{public:    RegisterClass(const std::string& className,construct constructMethod)    {        Reflex* factory = myUtil::Singleton<Reflex>::Instance();        factory->RegisterClass(className, constructMethod);    }    RegisterClass(const std::string& className,const std::string& fieldName,const std::string& fieldType,const size_t& offset)    {        Reflex* factory = myUtil::Singleton<Reflex>::Instance();        factory->RegisterField(className, fieldName, fieldType, offset);    }    RegisterClass(const std::string& className,const std::string& methodName,const uintptr_t& lpMethod)    {        Reflex* factory = myUtil::Singleton<Reflex>::Instance();        factory->RegisterMethod(className, methodName, lpMethod);    }};class Field{private:    std::string m_fieldType{""};    //std::string m_fieldName{""};    size_t m_offset{0};public:    Field(){}    Field(const std::string& fieldType,const size_t& offset):        m_fieldType(fieldType),m_offset(offset){}    ~Field(){}        inline std::string getFieldType(){return m_fieldType;}    //inline std::string getFieldName(){return m_fieldName;}    inline size_t getOffSet(){return m_offset;}    inline void setFieldType(const std::string& type){ m_fieldType = type;}    //inline void setFieldName(const std::string& name){ m_fieldName = name;}    inline void setOffSet(const size_t& offset){ m_offset = offset;}};class Method{public:    Method(){}    Method(const std::string& name,const std::uintptr_t& method):        methodName(name),lpMethod(method){}    ~Method(){}    inline void setMethodName(const std::string& name) { methodName = name;}    inline void setLpMethod(const uintptr_t& lp) { lpMethod = lp;}    inline std::string getMethodName(){return methodName;}    inline uintptr_t getLpMethod(){return lpMethod;}private:    std::string methodName{""};    std::uintptr_t lpMethod{0};};#define REGISTER_REFLEX(className)                                      \        RObject* construct##className()                                 \        {                                                               \            RObject* obj = new className();                             \            obj->_className = #className;                               \            return obj;                                                 \        }                                                               \        RegisterClass registerClass##className(#className,construct##className);#define REGISTER_REFLEX_FIELD(className,fieldType,fieldName)            \        RegisterClass registerClass##className##fieldType##fieldName(#className,#fieldName,#fieldType,OFFSET(className,fieldName));#define REGISTER_REFLEX_METHOD(className,methodName)                    \        std::function<void(className)> className##methodName = &className::methodName;\        RegisterClass registerClass##className##method(#className,#methodName,(std::uintptr_t)&className##methodName);#define REGISTER_REFLEX_METHOD_ARGS(className,methodName,returnType,...)                    \        std::function<returnType(className,##__VA_ARGS__)> className##methodName = &className::methodName;\        RegisterClass registerClass##className##method##returnType(#className,#methodName,(std::uintptr_t)&className##methodName);template<typename T>T RObject::get(const std::string &fieldName){    Reflex* factory = myUtil::Singleton<Reflex>::Instance();    return factory->getClassField<T>(this, _className, fieldName);}template<typename T>void RObject::set(const std::string &fieldName, const T &fieldValue){    Reflex* factory = myUtil::Singleton<Reflex>::Instance();    factory->setClassField(this, _className, fieldName, fieldValue);}void RObject::Call(const std::string& methodName){    Reflex* factory = myUtil::Singleton<Reflex>::Instance();    std::uintptr_t temp = factory->getClassMethod(_className, methodName);    if (temp == 0) return;    typedef std::function<void(decltype(this))> class_method;    class_method* method = (class_method*)temp;    (*method)(this);}template<typename T,typename... Args>T RObject::Call(const std::string& methodName,Args... args){    Reflex* factory = myUtil::Singleton<Reflex>::Instance();    std::uintptr_t temp = factory->getClassMethod(_className, methodName);    if(temp == 0) return T();    typedef std::function<T(decltype(this),Args...)> class_method;    class_method* method = (class_method*)temp;    return (*method)(this,args...);}RObject* Reflex::createClass(const std::string &className){    if(m_classMap.find(className)==m_classMap.end()) return nullptr;    return m_classMap[className]();}void Reflex::RegisterClass(const std::string &className, construct constructMethod){    if(m_classMap.find(className)!=m_classMap.end()){        throw std::exception();        return;    }    m_classMap.insert(std::pair<std::string, construct>(className,constructMethod));    m_fieldMap[className] = std::map<std::string, Field>();    m_methodMap[className] = std::map<std::string, uintptr_t>();}void Reflex::RegisterField(const std::string &className, const std::string &FieldName, const std::string &FieldType, const size_t &offset){    m_fieldMap[className][FieldName] = Field(FieldType,offset);}void Reflex::RegisterMethod(const std::string &className, const std::string &methodName, const uintptr_t &lpMethod){    m_methodMap[className][methodName] = lpMethod;}template<typename T>T Reflex::getClassField(void* originPos, const std::string &className, const std::string &fieldName){    if(m_fieldMap.find(className) == m_fieldMap.end()){        return T();    }    if(m_fieldMap[className].find(fieldName) == m_fieldMap[className].end()){        return T();    }    size_t offset = m_fieldMap[className][fieldName].getOffSet();    return *(T*)((size_t)originPos + offset);}template<typename T>void Reflex::setClassField(void* originPos, const std::string &className, const std::string &fieldName, const T &fieldValue){    if(m_fieldMap.find(className) == m_fieldMap.end()){        return;    }    if(m_fieldMap[className].find(fieldName) == m_fieldMap[className].end()){        return;    }    size_t offset = m_fieldMap[className][fieldName].getOffSet();    *(T*)((size_t)originPos + offset) = fieldValue;}uintptr_t Reflex::getClassMethod(const std::string &className, const std::string &methodName){    if(m_fieldMap.find(className) == m_fieldMap.end()){        return 0;    }    if(m_methodMap[className].find(methodName) == m_methodMap[className].end()){        return 0;    }    return m_methodMap[className][methodName];}NAME_SPACE_END()#endif //!_REFLEX_

该反射类使用方法如下：

#include <iOStream>#include <string>#include "Util.h"#include "Singleton.h"#include "Reflex.h"using namespace std;using namespace myUtil;class A:public RObject{public:    void show(){        cout<<"hello world"<<endl;    }    int add(int a,int b){        return a+b;    }    int m_age;    A():m_age(10){}};REGISTER_REFLEX(A)REGISTER_REFLEX_FIELD(A, int, m_age)REGISTER_REFLEX_METHOD(A, show)REGISTER_REFLEX_METHOD_ARGS(A, add, int,int,int)int main(){    Reflex* factory=Singleton<Reflex>::Instance();    A* a=(A*)factory->createClass("A");    cout<<a->get<int>("m_age")<<endl;    a->set<int>("m_age", 30);    cout << a->get<int>("m_age") << endl;    a->Call("show");    int b = a->Call<int,int,int>("add",1,5);    cout << b << endl;    A* c=(A*)factory->createClass("A");    cout<<c->get<int>("m_age")<<endl;    c->set<int>("m_age", 40);    cout << c->get<int>("m_age") << endl;    c->Call("show");    b = c->Call<int,int,int>("add",2,5);    cout << b << endl;    return 0;}

结果截图

最后讲解一下是怎么用的，见注释

//首先要使用反射的类要继承RObject//要使用反射的类和成员方法都要声明为publicclass A:public RObject{public:    void show(){        cout<<"hello world"<<endl;    }    int add(int a,int b){        return a+b;    }    int m_age;    A():m_age(10){}};//这里在反射类中注册A这个类，原理是把重复工作用宏展开来替代REGISTER_REFLEX(A)//注册类中的成员变量，一定要先注册类再注册成员变量，原理是将成员变量与对象的偏移量保存起来，用到的时候解引用来获取值REGISTER_REFLEX_FIELD(A, int, m_age)//注册类的成员方法，此宏是声明没有返回值和入参的成员方法的，原理是使用function能够调用成员函数的功能，将function的地址保存到注册表中（转为uintptr_t），需要时通过传入的参数转换回来，再调用REGISTER_REFLEX_METHOD(A, show)//注册类的成员方法，此宏是声明有返回值和多参数的成员方法的，原理同上REGISTER_REFLEX_METHOD_ARGS(A, add, int,int,int)int main(){//在使用类时，要先获取这个全局唯一的反射对象，使用它来创建对象    Reflex* factory=Singleton<Reflex>::Instance();    A* a=(A*)factory->createClass("A");    //为了能够得到准确的类型值，这里使用模板来获取    cout<<a->get<int>("m_age")<<endl;    //设置同获取    a->set<int>("m_age", 30);    cout << a->get<int>("m_age") << endl;    //调用无参且无返回值的成员函数时使用没有模板的Call，反之使用有模板的Call    a->Call("show");    int b = a->Call<int,int,int>("add",1,5);    cout << b << endl;    return 0;}

感谢各位的阅读，以上就是“怎么利用C++实现一个反射类”的内容了，经过本文的学习后，相信大家对怎么利用C++实现一个反射类这一问题有了更深刻的体会，具体使用情况还需要大家实践验证。这里是编程网，小编将为大家推送更多相关知识点的文章，欢迎关注！