C++模拟反射

最新推荐文章于 2025-05-27 11:39:31 发布

原创最新推荐文章于 2025-05-27 11:39:31 发布 · 532 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#c++ #string #class #function #iterator #exception

本文介绍了使用C++模拟反射的实现，通过宏定义和模板技术实现类的字段和方法的反射操作，包括设置和获取字段值以及调用方法。虽然作者认为这个实现可能并无实际用途，但提供了对反射概念的基础理解。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

写字太累，贴代码最犀利，只是自己实在想不到这样的实现有什么意义，仅仅是一个最基本功能的模拟，这两天闲得蛋疼，但是还是不敢再写了，怕是再深入下去自己踢球的时间都要被挤掉，就此打住，代码贴出来也只是希望不要忘得那么快。。。。。。以后少喝酒，少抽烟，多运动。

MB的一个好好的测试代码，被弄得面目全非，一堆球用没得的代码，为了实现这么一个破功能，蛋疼~~~~~~~~~

Header file:

#ifndef _CLASS_INFO_H #define _CLASS_INFO_H #include <string> #include <map> #include <iostream> using namespace std; ////////////////////////////////////////////////////////////////////////// struct NullType; struct EmptyClass {}; template <typename T> struct TypeContainer { typedef T type; }; template <typename T, typename U> struct TypeList { typedef T Head; typedef U Tail; }; #define TYPELIST_1(T1) TypeList<T1, NullType> #define TYPELIST_2(T1, T2) TypeList<T1, TYPELIST_1(T2) > #define TYPELIST_3(T1, T2, T3) TypeList<T1, TYPELIST_2(T2, T3) > #define TYPELIST_4(T1, T2, T3, T4) TypeList<T1, TYPELIST_3(T2, T3, T4) > #define TYPELIST_5(T1, T2, T3, T4, T5) TypeList<T1, TYPELIST_4(T2, T3, T4, T5) > #define TYPELIST_6(T1, T2, T3, T4, T5, T6) TypeList<T1, TYPELIST_5(T2, T3, T4, T5, T6) > #define TYPELIST_7(T1, T2, T3, T4, T5, T6, T7) TypeList<T1, TYPELIST_6(T2, T3, T4, T5, T6, T7) > #define TYPELIST_8(T1, T2, T3, T4, T5, T6, T7, T8) TypeList<T1, TYPELIST_7(T2, T3, T4, T5, T6, T7, T8) > #define TYPELIST_9(T1, T2, T3, T4, T5, T6, T7, T8, T9) TypeList<T1, TYPELIST_8(T2, T3, T4, T5, T6, T7, T8, T9) > #define TYPELIST_10(T1, T2, T3, T4, T5, T6, T7, T8, T9, T10) TypeList<T1, TYPELIST_9(T2, T3, T4, T5, T6, T7, T8, T9, T10) > ////////////////////////////////////////////////////////////////////////// #define FIELD_SET_FUNCTION_DIFINITION(name, type, value) / template <typename T> void name(T* pObj, type value) { / typedef void (T::*PFUNCTION)(void); / map<string, PFUNCTION>::iterator iter = pObj->mapFunctions.find("setValue"#type"_" + strFieldName); / if (iter == pObj->mapFunctions.end()) throw exception("Can not find field."); / typedef void (T::*SET)(type); / SET pGetFunc = (SET)iter->second; / (pObj->*pGetFunc)(value); / } #define FIELD_GET_FUNCTION_DEFINITION(name, type) / template <typename T> type name(T* pObj) { / typedef void (T::*PFUNCTION)(void); / map<string, PFUNCTION>::iterator iter = pObj->mapFunctions.find("getValue"#type"_" + strFieldName); / if (iter == pObj->mapFunctions.end()) throw exception("Can not find field."); / typedef type (T::*GET)(void); / GET pGetFunc = (GET)iter->second; / return (pObj->*pGetFunc)(); / } struct Reflect_Field { string strType; string strFieldName; FIELD_SET_FUNCTION_DIFINITION(setInt, int, value); FIELD_SET_FUNCTION_DIFINITION(setChar, char, value); FIELD_SET_FUNCTION_DIFINITION(setBool, bool, value); FIELD_SET_FUNCTION_DIFINITION(setLong, long, value); FIELD_SET_FUNCTION_DIFINITION(setDouble, double, value); FIELD_SET_FUNCTION_DIFINITION(setShort, short, value); FIELD_SET_FUNCTION_DIFINITION(setFloat, float, value); FIELD_GET_FUNCTION_DEFINITION(getInt, int); FIELD_GET_FUNCTION_DEFINITION(getChar, char); FIELD_GET_FUNCTION_DEFINITION(getBool, bool); FIELD_GET_FUNCTION_DEFINITION(getLong, long); FIELD_GET_FUNCTION_DEFINITION(getDouble, double); FIELD_GET_FUNCTION_DEFINITION(getShort, short); FIELD_GET_FUNCTION_DEFINITION(getFloat, float); }; struct Reflect_Method { template <typename T, typename R> R invoke(T* pObj) { typedef void (T::*PFUNCTION)(void); map<string, PFUNCTION>::iterator iter = pObj->mapFunctions.find(strRetType + "_" + strMethodName + "_void"); if (iter == pObj->mapFunctions.end()) throw exception("Can not find method."); typedef R (T::*FUNC)(void); FUNC pf = (FUNC)iter->second; return (pObj->*pf)(); } template <typename T, typename R, typename P> R invoke(T* pObj, P p) { typedef void (T::*PFUNCTION)(void); map<string, PFUNCTION>::iterator iter = pObj->mapFunctions.find(strRetType + "_" + strMethodName + "_" + strT1); if (iter == pObj->mapFunctions.end()) throw exception("Can not find method."); typedef R (T::*FUNC)(P); FUNC pf = (FUNC)iter->second; return (pObj->*pf)(p); } template <typename T, typename R, typename P1, typename P2> R invoke(T* pObj, P1 p1, P2 p2) { typedef void (T::*PFUNCTION)(void); map<string, PFUNCTION>::iterator iter = pObj->mapFunctions.find(strRetType + "_" + strMethodName + "_" + strT1 + "_" + strT2); if (iter == pObj->mapFunctions.end()) throw exception("Can not find method."); typedef R (T::*FUNC)(P1, P2); FUNC pf = (FUNC)iter->second; return (pObj->*pf)(p1, p2); } ////////////////////////////////////////////////////////////////////////// string strClass; string strMethodName; string strRetType; string strT1; string strT2; string strT3; string strT4; string strT5; string strT6; string strT7; string strT8; string strT9; }; struct Reflect_Class { Reflect_Field* getField(string strType, string strName) { map<string, Reflect_Field*>::iterator iter = mapField.find(strType + "_" + strName); if (iter == mapField.end()) return 0; return iter->second; } Reflect_Method* getMethod(string strMethod) { return getReflectMethod("method_void_" + strMethod + "_void"); } Reflect_Method* getMethod(string strMethod, string t1) { return getReflectMethod("method_" + t1 + "_" + strMethod + "_void"); } Reflect_Method* getMethod(string strMethod, string t1, string t2) { return getReflectMethod("method_" + t1 + "_" + strMethod + "_" + t2); } Reflect_Method* getMethod(string strMethod, string t1, string t2, string t3) { return getReflectMethod("method_" + t1 + "_" + strMethod + "_" + t2 + "_" + t3); } Reflect_Method* getMethod(string strMethod, string t1, string t2, string t3, string t4) { return getReflectMethod("method_" + t1 + "_" + strMethod + "_" + t2 + "_" + t3 + "_" + t4); } Reflect_Method* getMethod(string strMethod, string t1, string t2, string t3, string t4, string t5) { return getReflectMethod("method_" + t1 + "_" + strMethod + "_" + t2 + "_" + t3 + "_" + t4 + "_" + t5); } Reflect_Method* getMethod(string strMethod, string t1, string t2, string t3, string t4, string t5, string t6) { return getReflectMethod("method_" + t1 + "_" + strMethod + "_" + t2 + "_" + t3 + "_" + t4 + "_" + t5 + "_" + t6); } Reflect_Method* getMethod(string strMethod, string t1, string t2, string t3, string t4, string t5, string t6, string t7) { return getReflectMethod("method_" + t1 + "_" + strMethod + "_" + t2 + "_" + t3 + "_" + t4 + "_" + t5 + "_" + t6 + "_" + t7); } Reflect_Method* getMethod(string strMethod, string t1, string t2, string t3, string t4, string t5, string t6, string t7, string t8) { return getReflectMethod("method_" + t1 + "_" + strMethod + "_" + t2 + "_" + t3 + "_" + t4 + "_" + t5 + "_" + t6 + "_" + t7 + "_" + t8); } Reflect_Method* getMethod(string strMethod, string t1, string t2, string t3, string t4, string t5, string t6, string t7, string t8, string t9) { return getReflectMethod("method_" + t1 + "_" + strMethod + "_" + t2 + "_" + t3 + "_" + t4 + "_" + t5 + "_" + t6 + "_" + t7 + "_" + t8 + "_" + t9); } ////////////////////////////////////////////////////////////////////////// string strClassName; map<string, Reflect_Field*> mapField; map<string, Reflect_Method*> mapMethod; private: Reflect_Method* getReflectMethod(string strSig) { map<string, Reflect_Method*>::iterator iter = mapMethod.find(strSig); if (iter == mapMethod.end()) return 0; return iter->second; } }; ////////////////////////////////////////////////////////////////////////// extern map<string, Reflect_Class*> g_mapReflectClass; ////////////////////////////////////////////////////////////////////////// #define REFLECT_CLASS_DEFINITION(type) / static const string reflect_class_name_##type; / static Reflect_Class reflect_class_##type; / typedef void (type::*PFUNCTION)(void); / static map<string, PFUNCTION> mapFunctions; / static void InitReflect(); #define REFLECT_CLASS_IMPLEMENT(type) / Reflect_Class type::reflect_class_##type; / const string type::reflect_class_name_##type = "reflect_"#type; / typedef void (type::*PFUNCTION)(void); / map<string, PFUNCTION> type::mapFunctions; / void type::InitReflect() { / reflect_class_##type.strClassName = reflect_class_name_##type; / if (g_mapReflectClass.find(#type) == g_mapReflectClass.end()) / g_mapReflectClass.insert(make_pair(#type, &reflect_class_##type)); / } ////////////////////////////////////////////////////////////////////////// #define REFLECT_FIELD(type, t, name) t name; / t getValue##t_##name(); / void setValue##t_##name(t); / static Reflect_Field reflect_field_##t##_##name; / #define REFLECT_FIELD_IMPLEMENT(type, t, name) / t type::getValue##t_##name() { return name; } / void type::setValue##t_##name(t value) { name = value; } / Reflect_Field type::reflect_field_##t##_##name; #define REGISTER_FIELD(type, t, name) / if (reflect_class_##type.mapField.find(#t"_"#name) == reflect_class_##type.mapField.end()) { / reflect_class_##type.mapField.insert(make_pair(#t"_"#name, &reflect_field_##t##_##name)); / reflect_field_##t##_##name.strType = #t; / reflect_field_##t##_##name.strFieldName = #name; / mapFunctions.insert(make_pair("getValue"#t"_"#name, (PFUNCTION)&type::getValue##t_##name)); / mapFunctions.insert(make_pair("setValue"#t"_"#name, (PFUNCTION)&type::setValue##t_##name)); / } ////////////////////////////////////////////////////////////////////////// #define DEFINE_REFLECT_METHOD(r, n) / r n(); / static Reflect_Method reflect_method_##r_##n_void; #define IMPLEMENT_REFELCT_METHOD(type, r, n) / Reflect_Method type::reflect_method_##r_##n_void; #define REGISTER_REFLECT_METHOD(type, r, n) / if (reflect_class_##type.mapMethod.find("method_"#r"_"#n"_void") == reflect_class_##type.mapMethod.end()) { / reflect_class_##type.mapMethod.insert(make_pair("method_"#r"_"#n"_void", &reflect_method_##r_##n_void)); / reflect_method_##r_##n_void.strClass = #type; / reflect_method_##r_##n_void.strMethodName = #n; / reflect_method_##r_##n_void.strRetType = #r; / mapFunctions.insert(make_pair(#r"_"#n"_void", (PFUNCTION)&type::n)); / } ////////////////////////////////////////////////////////////////////////// #define DEFINE_REFLECT_METHOD_1(r, n, t) / r n(t); / static Reflect_Method reflect_method_##r_##n_##t; #define IMPLEMENT_REFELCT_METHOD_1(type, r, n, t) / Reflect_Method type::reflect_method_##r_##n_##t; #define REGISTER_REFLECT_METHOD_1(type, r, n, t) / if (reflect_class_##type.mapMethod.find("method_"#r"_"#n"_"#t) == reflect_class_##type.mapMethod.end()) { / reflect_class_##type.mapMethod.insert(make_pair("method_"#r"_"#n"_"#t, &reflect_method_##r_##n_##t)); / reflect_method_##r_##n_##t.strClass = #type; cout << #type << endl;/ reflect_method_##r_##n_##t.strMethodName = #n; / reflect_method_##r_##n_##t.strRetType = #r; / reflect_method_##r_##n_##t.strT1 = #t; / mapFunctions.insert(make_pair(#r"_"#n"_"#t, (PFUNCTION)&type::n)); / } ////////////////////////////////////////////////////////////////////////// #define DEFINE_REFLECT_METHOD_2(r, n, t1, t2) / r n(t1, t2); / static Reflect_Method reflect_method_##r_##n_##t1_##t2; #define IMPLEMENT_REFELCT_METHOD_2(type, r, n, t1, t2) / Reflect_Method type::reflect_method_##r_##n_##t1_##t2; #define REGISTER_REFLECT_METHOD_2(type, r, n, t1, t2) / if (reflect_class_##type.mapMethod.find("method_"#r"_"#n"_"#t1"_"#t2) == reflect_class_##type.mapMethod.end()) { / reflect_class_##type.mapMethod.insert(make_pair("method_"#r"_"#n"_"#t1"_"#t2, &reflect_method_##r_##n_##t1_##t2)); / reflect_method_##r_##n_##t1_##t2.strClass = #type; cout << #type << endl;/ reflect_method_##r_##n_##t1_##t2.strMethodName = #n; / reflect_method_##r_##n_##t1_##t2.strRetType = #r; / reflect_method_##r_##n_##t1_##t2.strT1 = #t1; / reflect_method_##r_##n_##t1_##t2.strT2 = #t2; / mapFunctions.insert(make_pair(#r"_"#n"_"#t1"_"#t2, (PFUNCTION)&type::n)); / } ////////////////////////////////////////////////////////////////////////// #define DEFINE_REFLECT_METHOD_3(r, n, t1, t2, t3) ////////////////////////////////////////////////////////////////////////// #define BEGINI_REFLECTION_INITIALIZE(type) / InitReflect(); / #define END_REFLECTION_INITIALIZE() ////////////////////////////////////////////////////////////////////////// extern Reflect_Class* getReflectClassInfo(string strClassName); #endif

Test code:

TestClass.h

#pragma once #include "ClassInfo.h" class CTestClass { public: CTestClass(void); ~CTestClass(void); public: REFLECT_CLASS_DEFINITION(CTestClass); REFLECT_FIELD(CTestClass, int, m_nTest); DEFINE_REFLECT_METHOD(void, Test); DEFINE_REFLECT_METHOD_1(int, Test2, int); DEFINE_REFLECT_METHOD_2(int, Test3, int, bool); };

TestClass.cpp

#include "TestClass.h" #include <iostream> using namespace std; ////////////////////////////////////////////////////////////////////////// REFLECT_CLASS_IMPLEMENT(CTestClass) REFLECT_FIELD_IMPLEMENT(CTestClass, int, m_nTest) IMPLEMENT_REFELCT_METHOD(CTestClass, void, Test) IMPLEMENT_REFELCT_METHOD_1(CTestClass, int, Test2, int) IMPLEMENT_REFELCT_METHOD_2(CTestClass, int, Test3, int, bool) ////////////////////////////////////////////////////////////////////////// CTestClass::CTestClass(void) { BEGINI_REFLECTION_INITIALIZE(CTestClass); REGISTER_FIELD(CTestClass, int, m_nTest); REGISTER_REFLECT_METHOD(CTestClass, void, Test); REGISTER_REFLECT_METHOD_1(CTestClass, int, Test2, int); REGISTER_REFLECT_METHOD_2(CTestClass, int, Test3, int, bool); END_REFLECTION_INITIALIZE() } CTestClass::~CTestClass(void) { } ////////////////////////////////////////////////////////////////////////// void CTestClass::Test() { cout << "This is a test reflect function..." << endl; } int CTestClass::Test2(int nValue) { cout << "int CTestClass::Test2(int nValue)" << endl; cout << "Test2: " << nValue * nValue << endl; return nValue * nValue; } int CTestClass::Test3(int nValue, bool bValue) { cout << "int CTestClass::Test3(int nValue, bool bValue)" << endl; return nValue * nValue; }

main.cpp

#include "ClassInfo.h" #include <iostream> #include "TestClass.h" int _tmain(int argc, _TCHAR* argv[]) { CTestClass testCls; testCls.m_nTest = 102; Reflect_Class* pClass = getReflectClassInfo("CTestClass"); Reflect_Field* pField = pClass->getField("int", "m_nTest"); cout << pField->getInt<CTestClass>(&testCls) << endl; pField->setInt<CTestClass>(&testCls, 12345); cout << pField->getInt<CTestClass>(&testCls) << endl; Reflect_Method* pMethod = pClass->getMethod("Test", "void"); pMethod->invoke<CTestClass, void>(&testCls); Reflect_Method* pMethod2 = pClass->getMethod("Test2", "int", "int"); pMethod2->invoke<CTestClass, int, int>(&testCls, 234); Reflect_Method* pMethod3 = pClass->getMethod("Test3", "int", "int", "bool"); pMethod3->invoke<CTestClass, int, int>(&testCls, 234, false); return 0; }