詳解如何利用C++實(shí)現(xiàn)一個(gè)反射類
更新時(shí)間：2023年03月09日 09:50:33 作者：咩~~
這篇文章主要為大家詳細(xì)介紹了如何利用C++實(shí)現(xiàn)一個(gè)反射類，文中的示例代碼講解詳細(xì)，具有一定的參考價(jià)值，感興趣的小伙伴可以跟隨小編一起學(xué)習(xí)一下
代碼環(huán)境為VScode + CMake + GCC 8.1.0
首先，如何才能做到給我一個(gè)名字我就能拿到這個(gè)對(duì)象的這個(gè)值，也是比較難的一個(gè)地方，方法如下
#define OFFSET(className,fieldName) (size_t)&(((className*)0)->fieldName)
這個(gè)能夠得到該成員變量與該對(duì)象的偏移量，之后根據(jù)這個(gè)偏移量來獲取成員的值
正題開始
首先這個(gè)反射類應(yīng)該只有一個(gè)，要不然反射就會(huì)變得很混亂，這一個(gè)反射對(duì)象，那里一個(gè)反射對(duì)象。所以應(yīng)該將該反射類變?yōu)橐粋€(gè)單例。全局內(nèi)只允許出現(xiàn)一個(gè)。單例類如下：
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_
我在這個(gè)頭文件中寫了一個(gè)單例聲明SINGLETON_DECLARE，只要將這個(gè)聲明放到私有部分就行了，這個(gè)類就變?yōu)橐粋€(gè)單例類了。
反射類
如何才能做到反射呢，應(yīng)該在這個(gè)反射類中保存注冊表，傳入了對(duì)應(yīng)的類名，返回對(duì)應(yīng)的信息，然后使用基類實(shí)現(xiàn)對(duì)應(yīng)的方法即可。代碼如下：
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>
//因?yàn)榫幾g器不支持類模板和實(shí)現(xiàn)分開寫，所以放到一起了
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;
}
結(jié)果截圖
最后講解一下是怎么用的，見注釋
//首先要使用反射的類要繼承RObject
//要使用反射的類和成員方法都要聲明為public
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){}
};
//這里在反射類中注冊A這個(gè)類，原理是把重復(fù)工作用宏展開來替代
REGISTER_REFLEX(A)
//注冊類中的成員變量，一定要先注冊類再注冊成員變量，原理是將成員變量與對(duì)象的偏移量保存起來，用到的時(shí)候解引用來獲取值
REGISTER_REFLEX_FIELD(A, int, m_age)
//注冊類的成員方法，此宏是聲明沒有返回值和入?yún)⒌某蓡T方法的，原理是使用function能夠調(diào)用成員函數(shù)的功能，將function的地址保存到注冊表中（轉(zhuǎn)為uintptr_t），需要時(shí)通過傳入的參數(shù)轉(zhuǎn)換回來，再調(diào)用
REGISTER_REFLEX_METHOD(A, show)
//注冊類的成員方法，此宏是聲明有返回值和多參數(shù)的成員方法的，原理同上
REGISTER_REFLEX_METHOD_ARGS(A, add, int,int,int)
int main(){
//在使用類時(shí)，要先獲取這個(gè)全局唯一的反射對(duì)象，使用它來創(chuàng)建對(duì)象
Reflex* factory=Singleton<Reflex>::Instance();
A* a=(A*)factory->createClass("A");
//為了能夠得到準(zhǔn)確的類型值，這里使用模板來獲取
cout<<a->get<int>("m_age")<<endl;
//設(shè)置同獲取
a->set<int>("m_age", 30);
cout << a->get<int>("m_age") << endl;
//調(diào)用無參且無返回值的成員函數(shù)時(shí)使用沒有模板的Call，反之使用有模板的Call
a->Call("show");
int b = a->Call<int,int,int>("add",1,5);
cout << b << endl;
return 0;
}
到此這篇關(guān)于詳解如何利用C++實(shí)現(xiàn)一個(gè)反射類的文章就介紹到這了,更多相關(guān)C++反射類內(nèi)容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關(guān)文章希望大家以后多多支持腳本之家！
相關(guān)文章
C語言實(shí)現(xiàn)運(yùn)動(dòng)會(huì)管理系統(tǒng)
這篇文章主要為大家詳細(xì)介紹了C語言實(shí)現(xiàn)運(yùn)動(dòng)會(huì)管理系統(tǒng)，文中示例代碼介紹的非常詳細(xì)，具有一定的參考價(jià)值，感興趣的小伙伴們可以參考一下2022-05-05
這篇文章主要介紹了C++11中std::future的具體使用方法，文中通過示例代碼介紹的非常詳細(xì)，對(duì)大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2020-01-01
雖然不能直接實(shí)現(xiàn)一對(duì)下標(biāo)操作符重載，但是我們可以間接模擬。思路是這樣的，先通過單下標(biāo)操作返回一個(gè)具有下標(biāo)操作能力的左值，對(duì)左值進(jìn)行下標(biāo)操作，兩個(gè)下標(biāo)操作表達(dá)式聯(lián)立就實(shí)現(xiàn)了雙下標(biāo)操作2013-09-09
uboot 屬于bootloader的一種，是用來引導(dǎo)啟動(dòng)內(nèi)核的，它的最終目的就是從flash中讀出內(nèi)核，放到內(nèi)存中，啟動(dòng)內(nèi)核，這篇文章主要介紹了uboot添加自定義命令的實(shí)現(xiàn)步驟,需要的朋友可以參考下2022-11-11
Boost是為C++語言標(biāo)準(zhǔn)庫提供擴(kuò)展的一些C++程序庫的總稱。Boost庫是一個(gè)可移植、提供源代碼的C++庫，作為標(biāo)準(zhǔn)庫的后備，是C++標(biāo)準(zhǔn)化進(jìn)程的開發(fā)引擎之一，是為C++語言標(biāo)準(zhǔn)庫提供擴(kuò)展的一些C++程序庫的總稱2022-12-12
這篇文章主要介紹了C++中對(duì)象與類的詳解及其作用介紹，本文給大家介紹的非常詳細(xì)，對(duì)大家的學(xué)習(xí)或工作具有一定的參考借鑒價(jià)值，需要的朋友可以參考下2021-09-09
C語言實(shí)現(xiàn)十六進(jìn)制轉(zhuǎn)換為十進(jìn)制的方法詳解
這篇文章主要為大家詳細(xì)介紹了C語言實(shí)現(xiàn)十六進(jìn)制轉(zhuǎn)換為十進(jìn)制的方法，文中的示例代碼講解詳細(xì)，具有一定的借鑒價(jià)值，需要的可以參考一下2022-11-11
單元測試（unit testing），是指對(duì)軟件中的最小可測試單元進(jìn)行檢查和驗(yàn)證。這篇文章主要為大家介紹了C語言實(shí)現(xiàn)單元測試的方法，需要的可以參考一下2022-09-09
本文主要介紹如何制作DLL，將代碼類中的方法以接口的形式暴露出來給exe程序使用。會(huì)涉及類廠創(chuàng)建方法實(shí)例、聲明DLL接口、.def文件的使用等，感興趣的可以了解一下2023-04-04
C++如何計(jì)算結(jié)構(gòu)體與對(duì)象的大小
這篇文章主要給大家介紹了關(guān)于C++如何計(jì)算結(jié)構(gòu)體與對(duì)象大小的相關(guān)資料，文中通過示例代碼介紹的非常詳細(xì)，對(duì)大家的學(xué)習(xí)或者工作具有一定的參考學(xué)習(xí)價(jià)值，需要的朋友們下面隨著小編來一起學(xué)習(xí)學(xué)習(xí)吧2021-05-05