C++类成员反射实现

最新推荐文章于 2024-08-28 03:46:55 发布
最新推荐文章于 2024-08-28 03:46:55 发布
阅读量2.1k 收藏 10
点赞数 4

引出问题：

给定一个我们自己定义的类A，如何便捷的输出其所有的成员变量类型及值。

日常编程中有这样的需求，一个是为了调试，二个是为了在不同模块运行时得到类的属性用于显示及修改。但C++未提供原生的反射机制，所以有了以下思考。

核心的需求为：对于一个类型A，我们可以拥有其所有的类型信息。例如：


class A
{
    int INT;
    float FLT;
}

/*MAIN*/
A a;
a.INT = 1;
a.FLT = 2.0f;
{
    for(auto& var : a.attr())
        cout << var;
}

其输出结果应类似:
int INT 1
float FLT 2.0
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19

找了一些资料来看，我们手头上已经有了一个实现版本，直接给出源码：

#include <iostream>

#include <vector>
#include <map>
#include <string>


#define _OFFSET_(_Obj_Ty,_Key)                                                    \
    ((unsigned long)(&((_Obj_Ty *)0)->_Key))

#define CLASS_REGISTER(_Obj_Ty)                                                    \
public:                                                                            \
    static tat::tat_class * get_class_ptr()                                        \
    {                                                                            \
        static tat::tat_class __class_##_Obj_Key##__;                            \
        return &__class_##_Obj_Key##__;                                            \
    }

#define FIELD_REGISTER(_Access,_Field_Ty,_Field_Key,_Obj_Ty)                    \
_Access:                                                                        \
    _Field_Ty _Field_Key;                                                        \
private:                                                                        \
    class __field_register_##_Field_Key##__                                        \
    {                                                                            \
    public:                                                                        \
        __field_register_##_Field_Key##__()                                        \
        {                                                                        \
            static tat::__field_register__ reg_##_Field_Key(                    \
                _Obj_Ty::get_class_ptr(),                                        \
                _OFFSET_(_Obj_Ty,_Field_Key),                                    \
                #_Field_Key);                                                    \
        }                                                                        \
    }_Field_Key##_register;

namespace tat
{
    class tat_field
    {
    private:
        unsigned long _offset;
        std::string _key;
    public:
        tat_field(unsigned long offset, std::string key) :_offset(offset), _key(key) {}
        tat_field(const tat_field &field)
        {
            this->_offset = field._offset;
            this->_key = field._key;
        }
    public:
        template<typename _Obj_Ty, typename _Value_Ty>
        void get(_Obj_Ty *obj, _Value_Ty &value)
        {
            value = *((_Value_Ty *)((unsigned char *)obj + _offset));
        }
        template<typename _Obj_Ty, typename _Value_Ty>
        void set(_Obj_Ty *obj, const _Value_Ty &value)
        {
            *((_Value_Ty *)((unsigned char *)obj + _offset)) = value;
        }
        std::string get_key() const
        {
            return this->_key;
        }
    };

    class tat_class
    {
    private:
        std::map<std::string, tat_field> _field_map;
        std::string _key;
    public:
        std::map<std::string, tat_field> get_fields()
        {
            return this->_field_map;
        }
        tat_field get_field(std::string key)
        {
            std::map<std::string, tat_field>::iterator itr = _field_map.find(key);
            return (*itr).second;
        }
        void add_field(const tat_field &field)
        {
            _field_map.insert(std::pair<std::string, tat_field>(field.get_key(), field));
        }
    };

    class __field_register__
    {
    public:
        __field_register__(tat_class *class_ptr, unsigned long offset, std::string key)
        {
            tat_field field(offset, key);
            class_ptr->add_field(field);
        }
    };

};


class TestClass
{
public:
    TestClass() = default;
    ~TestClass() = default;

    CLASS_REGISTER(TestClass)
        FIELD_REGISTER(public, long, _long_f, TestClass)
        FIELD_REGISTER(public, int, _int_f, TestClass)
        FIELD_REGISTER(public, std::string, _str_f, TestClass)
        FIELD_REGISTER(public, std::vector<int>, _vec_f, TestClass)
};



void main()
{
    TestClass inst;

    tat::tat_class *test_class = TestClass::get_class_ptr();
    std::map<std::string, tat::tat_field> field_map = test_class->get_fields();


    for (auto& var : field_map)
    {
        std::cout << var.first << std::endl;
    }

    tat::tat_field test_vec_field = field_map.find("_vec_f")->second;
    std::vector<int> vec;
    test_vec_field.get(&inst, vec);
    vec.push_back(22);
    test_vec_field.set(&inst, vec);
    std::cout << inst._vec_f[0] << std::endl;
}
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28
  • 29
  • 30
  • 31
  • 32
  • 33
  • 34
  • 35
  • 36
  • 37
  • 38
  • 39
  • 40
  • 41
  • 42
  • 43
  • 44
  • 45
  • 46
  • 47
  • 48
  • 49
  • 50
  • 51
  • 52
  • 53
  • 54
  • 55
  • 56
  • 57
  • 58
  • 59
  • 60
  • 61
  • 62
  • 63
  • 64
  • 65
  • 66
  • 67
  • 68
  • 69
  • 70
  • 71
  • 72
  • 73
  • 74
  • 75
  • 76
  • 77
  • 78
  • 79
  • 80
  • 81
  • 82
  • 83
  • 84
  • 85
  • 86
  • 87
  • 88
  • 89
  • 90
  • 91
  • 92
  • 93
  • 94
  • 95
  • 96
  • 97
  • 98
  • 99
  • 100
  • 101
  • 102
  • 103
  • 104
  • 105
  • 106
  • 107
  • 108
  • 109
  • 110
  • 111
  • 112
  • 113
  • 114
  • 115
  • 116
  • 117
  • 118
  • 119
  • 120
  • 121
  • 122
  • 123
  • 124
  • 125
  • 126
  • 127
  • 128
  • 129
  • 130
  • 131
  • 132
  • 133
  • 134

首先是#define CLASS_REGISTER(_Obj_Ty)宏，该宏在类体中加入了一个静态函数

#define CLASS_REGISTER(_Obj_Ty)                                                    \
public:                                                                            \
    static tat::tat_class * get_class_ptr()                                        \
    {                                                                            \
        static tat::tat_class __class_##_Obj_Key##__;                            \
        return &__class_##_Obj_Key##__;                                            \
    }
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7

所以我们可以通过类名或实例来获取到反射信息的指针。这里静态局部实例为__class_CLASSNAME__,他是一个tat::tat_class类型的值。那么我们接下来看tat::tat_class的定义。

    class tat_class
    {
    private:
        std::map<std::string, tat_field> _field_map;
        std::string _key;
    public:
        std::map<std::string, tat_field> get_fields()
        {
            return this->_field_map;
        }
        tat_field get_field(std::string key)
        {
            std::map<std::string, tat_field>::iterator itr = _field_map.find(key);
            return (*itr).second;
        }
        void add_field(const tat_field &field)
        {
            _field_map.insert(std::pair<std::string, tat_field>(field.get_key(), field));
        }
    };
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20

很明显可以看出，类中用一个Map去保存了我们需要的信息。公有的几个函数都是去查找或者添加对应的信息使用。而Map中的值是以tat::tat_field这个类去保存的。接下来看看这个类的实现。

    class tat_field
    {
    private:
        unsigned long _offset;
        std::string _key;
    public:
        tat_field(unsigned long offset, std::string key) :_offset(offset), _key(key) {}
        tat_field(const tat_field &field)
        {
            this->_offset = field._offset;
            this->_key = field._key;
        }
    public:
        template<typename _Obj_Ty, typename _Value_Ty>
        void get(_Obj_Ty *obj, _Value_Ty &value)
        {
            value = *((_Value_Ty *)((unsigned char *)obj + _offset));
        }
        template<typename _Obj_Ty, typename _Value_Ty>
        void set(_Obj_Ty *obj, const _Value_Ty &value)
        {
            *((_Value_Ty *)((unsigned char *)obj + _offset)) = value;
        }
        std::string get_key() const
        {
            return this->_key;
        }
    };
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15
  • 16
  • 17
  • 18
  • 19
  • 20
  • 21
  • 22
  • 23
  • 24
  • 25
  • 26
  • 27
  • 28

从类的定义中，我们可以看出。类保存的关键值就是两个，一个是属性对应类的偏移，一个是属性对应的名称。其公有接口利用模板实现了类型的判断，对于属性的类型，我们就不需要手动去声明了。那么现在的问题就只有如何在我们定义的时候获取到对应属性的偏移了。最终的宏命令

#define FIELD_REGISTER(_Access,_Field_Ty,_Field_Key,_Obj_Ty)                    \
_Access:                                                                        \
    _Field_Ty _Field_Key;                                                        \
private:                                                                        \
    class __field_register_##_Field_Key##__                                        \
    {                                                                            \
    public:                                                                        \
        __field_register_##_Field_Key##__()                                        \
        {                                                                        \
            static tat::__field_register__ reg_##_Field_Key(                    \
                _Obj_Ty::get_class_ptr(),                                        \
                _OFFSET_(_Obj_Ty,_Field_Key),                                    \
                #_Field_Key);                                                    \
        }                                                                        \
    }_Field_Key##_register;
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9
  • 10
  • 11
  • 12
  • 13
  • 14
  • 15

我们在定义类成员时，使用的是FIELD_REGISTER(public, long, _long_f, TestClass)，对应宏来看他到底做了什么。

首先宏将对应值的public属性放在了最前面，使得对应定义的值为公有。然后第二个参数和第三个参数为值的类型及标识，拓展以后就变成了原生C++的定义方式。最重要的是，在此之后，宏生成了一个私有的类，类的名称为 __field_register_##_Field_Key##__，并生成了一个实例_Field_Key##_register。这个类只有一个构造函数。构造函数中，生成了一个静态对象static tat::__field_register__ reg__long_f(...)，这个tat::__field_register__的类型是最后一个类，定义如下：

    class __field_register__
    {
    public:
        __field_register__(tat_class *class_ptr, unsigned long offset, std::string key)
        {
            tat_field field(offset, key);
            class_ptr->add_field(field);
        }
    };
  • 1
  • 2
  • 3
  • 4
  • 5
  • 6
  • 7
  • 8
  • 9

构造函数中，传进了一个tat_class的指针，一个偏移，和一个属性名称。然后构造函数会构造一个tat::tat_field，并将其加入到tat_class中。

所以在上面，我们最终就会把对应的类型信息加入到map中，最后就可以通过map获取到属性的名称，偏移。从而修改其值。（是不是很简单 - -！）

我觉得最黑科技的宏就是如何去取对应属性的偏移量这个宏，我诈一看认为会非法内存，没想到竟然不会。我们来看看：

#define _OFFSET_(_Obj_Ty,_Key)                                                    \
    ((unsigned long)(&((_Obj_Ty *)0)->_Key))
  • 1
  • 2

首先将0强转成class *的指针，然后去取对应属性的地址。这样我们取到的值就是对于0的偏移量也就是对应属性实际的偏移量了。（好黑科技啊。。。。）

理解完这个套路以后，我们就可以相应的实现一些我们自己的反射系统了。OK

yousss
关注
c++实现反射demo
08-09
用c++实现了反射
通过反射获取成员方法并且通过成员变量赋值
weixin_57219176的博客
06-08 267
通过反射获取成员方法并且通过成员变量赋值
C++动态反射第二版
最新发布
m0_56662207的博客
08-28 301
C++ 动态反射第二版
C++对象模型(获取成员变量)
noticmp的专栏
09-17 1795
注:获取成员变量需要添加this指针. #include #include #include using namespace std; // template // void GetAddr(ToType &addr, FromType f) // { // union // { // FromType _f; // ToType _t
C++反射机制的实现
flyingleo1981的专栏
06-19 1143
前几天用C++为《捕鱼达人》移植UI编辑器的时候，遇到了几个难点。一个是通过类名的字符串创建相应的类的实例化。还有一个是通过属性的名字字符串来操作相应的类的属性。用支持反射的Objective-C或者Java语言来实现类似功能是非常简单的。但是C++不支持，纠结了几天，终于实现了类似于反射的功能。 思路分为以下几步： 1、在要反射的类中定义一个回调函数，用来创建这个类的实例； 2、设计一个工
c++实现反射机制
akkk1kkka的博客
04-10 2211
一、问题的提出 在c++程序中，如果知道了一个类，然后我们就可以使用类名去访问这个类的 静态公有成员变量 或 静态成员函数： 类名::静态公有成员变量; 类名::静态公有成员函数; 或者我们可以创建这个类的一个对象，然后通过对象去访问公有成员变量 或 公有成员函数： 类名 *pobj = new 类名(); pobj -> ...
反射（获取成员变量，获取成员方法）
cgj-horizons
07-27 2149
FieldgetField(Stringname)返回单个成员变量对象（只能拿Public修饰的）Method[]getMethods()返回所有成员方法对象的数组（只能返回为public修饰的）Field[]getFields()返回所有成员变量对象的数组（只能拿public修饰的）参数2调用方法的传递的参数（如果没有就不写）返回值方法的返回值（如果没有就不写）反射的第一步是先得到类对象，然后从类对象中获取类的成分对象。反射的第一步是先得到类对象，然后从类对象中后去类的成分对象。...
UE4 C++ 利用反射获取到类、类的成员
热门推荐
qq_40026009的博客
03-26 1万+
一、获取到特定类的对象实例 1.1、GetObjectsOfClass GetObjectsOfClass(类型::GetStaticClass(),存储结果的数组); TArray<UObject*> Objs; GetObjectsOfClass(UClass::StaticClass(), Objs); TArray<UObject*> ActorObjs; ...
用c++11 实现类名反射对象
zhoumanman20的博客
07-24 1312
由于最近工作中用到工厂模式来创建不同的窗口对象在主窗口中显示， 以前遇到类似的情况我都是把所有需要创建的窗口类头文件都包含到主窗口MainWnd.cpp中， 这样每新增一个窗口， 就需要修改 MainWnd.cpp 。MainWnd.cpp 也就需要重新编译。后来百度了下c++反射， 有用Qt 元对象机制的（Qt继承自QObject 的类是可以支持反射的）； 有用模版实现的类工厂， 然后需要反射的类从该类继承； 也有模仿MFC 的（需要在类的声明和实现中加入相关宏）... 感觉都有点麻烦。 后来再百度..
reflector:C++ 的反射系统（从 PDB 文件中提取信息）
06-16
在C++社区中，开发人员已经探索出利用调试信息（如PDB文件）来实现更全面的反射系统。 标题“reflector:C++ 的反射系统（从PDB文件中提取信息）”指出了一个项目或工具，它利用C++程序的调试信息（Program Database...
C++访问类中私有成员变量的方法
12-22
原则上，C++类中私有变量不允许在类之外的其他任何地方访问，一般来说功能完善的类都会提供get，set方法来操作类属性值，还有是是通过友元访问。但是！但如果没有get、set方法都没有提供，也没有定义友元，比如使用...
C++实现反射机制
10-22
在C++实现反射时，我们可以创建一个单例类`ReflectionManager`，这个类将存储所有已知类的信息。为了实现这一点，每个类需要声明一些元数据，例如类名、成员函数等。这些元数据可以存储在一个结构体或类中，然后在类...
C++编译期反射实践——以AOP实现为例
CppYyds的博客
11-26 1929
自古以来，C++就一直缺少一个编程语言的重要特性——反射，但如果熟悉C++元模板编程的同学，就知道以C++的风格，肯定是不会在标准库中添加运行时的反射支持的，从最新的C++版本演进来看，倒是编译期反射可能得到更好的支持。C++11 -> C++14 -> C++17 -> C++20… 不断让元模板编程变得更简单，更规范。本次的编译期反射实践，代码要求的最低C++版本为14，因为用到了 make_shared、decay_t。本次实践的完整代码仓库：MyUtil/tree/master/aop我们如何判断某
[进阶]反射-获取成员变量和方法对象并使用
m0_68783582的博客
06-23 357
/调用无参数的run方法，用cat对象出发调用的。System.out.println("有参数构造器执行了～");System.out.println("有参数构造器执行了～");System.out.println("无参构造器执行了～");System.out.println("无参构造器执行了～");System.out.println("🐈跑的好快～");System.out.println("🐈爱吃猫粮～");
C++中直接存取类私有成员
Hakuna Matata
01-24 3795
 本文谈到的问题是，在C++中究竟有没有办法访问类的私有成员，以及如何实现。主要针对菜鸟，老鸟们就不要看了。 读到《C++编程思想》48页，“3.4 对象布局”一节时，看到这样一段话：  存取指定符是struct的一部分，他并不影响这个struct产生的对象，程序开始运行时，所有的存取指定信息都消失了。存取指定信息通常是在编译期间消失的。在程序运行期间，对象变成了一个存储区域，别无他物，因此，
C++实现反射
野生的声威的专栏
01-12 6623
前言 首先，C++不同于C#或者Java，没有自带反射机制，只能通过C++一些传统艺能变着法地实现。 有哪些反射 1、类对象反射：简单地说就是程序运行时读进来一个字符串，然后程序就会自动创建出字符串对应名字的类对象 2、类属性反射：能够遍历得到类的所有成员，知道它们的数据类型和名字。最实际的例子就是Unreal和Unity中UI的实现，当定义一个类成员变量时，它就能在UI中显示出来。而不需...
36_C++_【初始化类内成员、设置类内成员、获取类内成员信息】【类数组的设置】【友元函数放置】【友元类顺序！】的操作——额外注意【友元类】
HanLongXia的博客
08-11 160
Person.h #ifndef PERSON_H #define PERSON_H using namespace std; #include<cstring> #include<stdlib.h> #include<stdio.h> #include<iostream> extern void police();//全局友元函数！！！ class Human;//友元类 class Person { public: friend void po
使用C++实现在类中存储成员信息并实现存取
m0_56868950的博客
04-12 450
C++类实现成员信息动态存取
C++反射机制实现与对象序列化
"C++ 反射机制是一种允许程序在运行时获取类信息并进行操作的技术，通常用于动态创建对象、访问成员变量和调用方法等。C++原生不支持反射，但可以通过自定义的方式模拟实现。本文将介绍一种简单的反射机制实现方法，...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值