C++ 反射

最新推荐文章于 2025-02-13 14:35:58 发布
最新推荐文章于 2025-02-13 14:35:58 发布
阅读量4.9k 收藏 22
点赞数 1
分类专栏： # C/C++ 组件、技巧 文章标签： c++
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.youkuaiyun.com/wanglei_11/article/details/127946617
版权

概念：

    反射机制允许程序在运行时借助Reflection API 取得任何类的内部信息，并能直接操作对象的内部属性和方法。

问题：

  1：c++不支持反射

  2：很多业务场景需要依赖反射机制，比如rpc、web mvc 、对象序列化。

目标：

  类对象的反射

  类成员数据的反射

  类成员函数的反射

  用法：

#include <iostream>
using namespace std;

#include "ClassFactory.h"
using namespace yazi::reflect;

#include "test/A.h"

int main()
{
    ClassFactory * factory = Singleton<ClassFactory>::instance();
    Object * a = factory->create_class("A");
    
    string name;
    a->get("m_name", name);
    a->set("m_name", "kitty");

    int age;
    a->get("m_age", age);
    a->set("m_age", 30);

    a->call("f1");
    int num = a->call<int>("f2", 123);

    return 0;
}

  类对象的反射：

   先创建下模板单例类

  Singleton.h

#pragma once

namespace yazi {
namespace utility {

template <typename T>
class Singleton
{
public:
    static T * instance()
    {
        if (m_instance == NULL)
            m_instance = new T();
        return m_instance;
    }

private:
    Singleton() {}
    Singleton(const Singleton<T> &);
    Singleton<T> & operator = (const Singleton<T> &);
    ~Singleton() {}

private:
    static T * m_instance;
};

template <typename T>
T * Singleton<T>::m_instance = NULL;

}}

   ClassFactory.h

#pragma once

#include <iostream>
#include <string>
#include <vector>
#include <map>
#include <functional>
using namespace std;

#include "Singleton.h"
using namespace yazi::utility;

#include "ClassField.h"
#include "ClassMethod.h"

namespace yazi {
namespace reflect {

class Object
{
public:
    Object();
    virtual ~Object();

    void set_class_name(const string & className);
    const string & get_class_name() const;

    int get_field_count();
    ClassField * get_field(int pos);
    ClassField * get_field(const string & fieldName);

    template <typename T>
    void get(const string & fieldName, T & value);

    template <typename T>
    void set(const string & fieldName, const T & value);
    void set(const string & fieldName, const char * value);
    
    template <typename R = void, typename ...Args>
    R call(const string & methodName, Args... args);

private:
    string m_className;
};

typedef Object * (*create_object)(void);

class ClassFactory
{
    friend class Singleton<ClassFactory>;
public:
    // reflect class
    void register_class(const string & className, create_object method);
    Object * create_class(const string & className);

    // reflect class field
    void register_class_field(const string & className, const string & fieldName, const string & fieldType, size_t offset);
    int get_class_field_count(const string & className);
    ClassField * get_class_field(const string & className, int pos);
    ClassField * get_class_field(const string & className, const string & fieldName);

    // reflect class method
    void register_class_method(const string & className, const string &methodName, uintptr_t method);
    int get_class_method_count(const string & className);
    ClassMethod * get_class_method(const string & className, int pos);
    ClassMethod * get_class_method(const string & className, const string & methodName);

private:
    ClassFactory() {}
    ~ClassFactory() {}

private:
    std::map<string, create_object> m_classMap;
    std::map<string, std::vector<ClassField *>> m_classFields;
    std::map<string, std::vector<ClassMethod *>> m_classMethods;
};

template <typename T>
void Object::get(const string & fieldName, T & value)
{
    ClassField * field = Singleton<ClassFactory>::instance()->get_class_field(m_className, fieldName);
    size_t offset = field->offset();
    value = *((T *)((unsigned char *)(this) + offset));
}

template <typename T>
void Object::set(const string & fieldName, const T & value)
{
    ClassField * field = Singleton<ClassFactory>::instance()->get_class_field(m_className, fieldName);
    size_t offset = field->offset();
    *((T *)((unsigned char *)(this) + offset)) = value;
}

template <typename R, typename ...Args>
R Object::call(const string & methodName, Args... args)
{
    ClassFactory * factory = Singleton<ClassFactory>::instance();
    ClassMethod * method = factory->get_class_method(m_className, methodName);
    auto func = method->method();
    typedef std::function<R(decltype(this), Args...)> class_method;
    return (*((class_method *)func))(this, args...);
}

}
}

 ClassFactory.cpp

#include "ClassFactory.h"
using namespace yazi::reflect;

Object::Object() : m_className("")
{
}

Object::~Object()
{
}

void Object::set_class_name(const string & className)
{
    m_className = className;
}

const string & Object::get_class_name() const
{
    return m_className;
}

int Object::get_field_count()
{
    return Singleton<ClassFactory>::instance()->get_class_field_count(m_className);
}

ClassField * Object::get_field(int pos)
{
    return Singleton<ClassFactory>::instance()->get_class_field(m_className, pos);
}

ClassField * Object::get_field(const string & fieldName)
{
    return Singleton<ClassFactory>::instance()->get_class_field(m_className, fieldName);
}

void Object::set(const string & fieldName, const char * value)
{
    ClassField * field = Singleton<ClassFactory>::instance()->get_class_field(m_className, fieldName);
    size_t offset = field->offset();
    *((string *)((unsigned char *)(this) + offset)) = string(value);
}

void ClassFactory::register_class(const string & className, create_object method)
{
    m_classMap[className] = method;
}

Object * ClassFactory::create_class(const string & className)
{
    auto it = m_classMap.find(className);
    if (it == m_classMap.end())
    {
        return nullptr;
    }
    return it->second();
}

void ClassFactory::register_class_field(const string & className, const string & fieldName, const string & fieldType, size_t offset)
{
    m_classFields[className].push_back(new ClassField(fieldName, fieldType, offset));
}

int ClassFactory::get_class_field_count(const string & className)
{
    return m_classFields[className].size();
}

ClassField * ClassFactory::get_class_field(const string & className, int pos)
{
    int size = m_classFields[className].size();
    if (pos < 0 || pos >= size)
    {
        return nullptr;
    }
    return m_classFields[className][pos];
}

ClassField * ClassFactory::get_class_field(const string & className, const string & fieldName)
{
    auto fields = m_classFields[className];
    for (auto it = fields.begin(); it != fields.end(); it++)
    {
        if ((*it)->name() == fieldName)
        {
            return *it;
        }
    }
    return nullptr;
}

void ClassFactory::register_class_method(const string & className, const string &methodName, uintptr_t method)
{
    m_classMethods[className].push_back(new ClassMethod(methodName, method));
}

int ClassFactory::get_class_method_count(const string & className)
{
    return m_classMethods[className].size();
}

ClassMethod * ClassFactory::get_class_method(const string & className, int pos)
{
    int size = m_classMethods[className].size();
    if (pos < 0 || pos >= size)
    {
        return nullptr;
    }
    return m_classMethods[className][pos];
}

ClassMethod * ClassFactory::get_class_method(const string & className, const string & methodName)
{
    auto methods = m_classMethods[className];
    for (auto it = methods.begin(); it != methods.end(); it++)
    {
        if ((*it)->name() == methodName)
        {
            return *it;
        }
    }
    return nullptr;
}

其中ClassFactory中有个友元类Singleton，这样Singleteon就可以调用ClassFactory工厂类中的api了。

其中ClassRegister.h 是注册类、注册元素、和注册方法的类。类中获取单列类Singleton的接口，在用此接口依次注册类、元素、方法。

ClassRegister.h：

#pragma once

#include "ClassFactory.h"

namespace yazi {
namespace reflect {

class ClassRegister
{
public:
    ClassRegister(const string & className, create_object method)
    {
        // register class
        Singleton<ClassFactory>::instance()->register_class(className, method);
    }

    ClassRegister(const string & className, const string & fieldName, const string & fieldType, uintptr_t offset)
    {
        // register class field
        Singleton<ClassFactory>::instance()->register_class_field(className, fieldName, fieldType, offset);
    }

    ClassRegister(const string & className, const string & methodName, uintptr_t method)
    {
        // register class method
        Singleton<ClassFactory>::instance()->register_class_method(className, methodName, method);
    }
};


#define REGISTER_CLASS(className)                                       \
    Object * createObject##className()                                  \
    {                                                                   \
        Object * obj = new className();                                 \
        obj->set_class_name(#className);                                \
        return obj;                                                     \
    }                                                                  	\
    ClassRegister classRegister##className(#className, createObject##className)

#define REGISTER_CLASS_FIELD(className, fieldName, fieldType) \
    className className##fieldName; \
    ClassRegister classRegister##className##fieldName(#className, #fieldName, #fieldType, (size_t)(&(className##fieldName.fieldName)) - (size_t)(&className##fieldName))

#define REGISTER_CLASS_METHOD(className, methodName, returnType, ...) \
    std::function<returnType(className *, ##__VA_ARGS__)> className##methodName##method = &className::methodName; \
    ClassRegister classRegister##className##methodName(#className, #methodName, (uintptr_t)&(className##methodName##method))

}
}

其中REGISTER_CLASS(className)宏主要做两件事，一：创建classname的对象函数，调用ClassRegister向工厂类中注册。

要注册的类：

#pragma once

#include <string>
using namespace std;

#include "ClassRegister.h"
using namespace yazi::reflect;


class A : public Object
{
public:
    A() : m_name("a"), m_age(18) {}

    void f1()
    {
        std::cout << "f1" << std::endl;
    }

    int f2(int a)
    {
        std::cout << "f2" << std::endl;
        return a;
    }

public:
    string m_name;
    int m_age;
};

REGISTER_CLASS(A);
REGISTER_CLASS_FIELD(A, m_name, string);
REGISTER_CLASS_FIELD(A, m_age, int);
REGISTER_CLASS_METHOD(A, f1, void);
REGISTER_CLASS_METHOD(A, f2, int, int);

类成员数据的反射：

  关键问题：如何获取类成员数据的内存地址偏移量。

  下面是具体的两种方法。

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

Test t;
size_t offset = (size_t)(&(t.member)) - (size_t)(&t);

 ClassField.h

#pragma once

#include <string>
using namespace std;

namespace yazi {
namespace reflect {

class ClassField
{
public:
    ClassField() : m_name(""), m_type(""), m_offset(0) {}
    ClassField(const string & name, const string & type, size_t offset) : m_name(name), m_type(type), m_offset(offset) {}
    ~ClassField() {}

    const string & name()
    {
        return m_name;
    }

    const string & type()
    {
        return m_type;
    }

    size_t offset()
    {
        return m_offset;
    }

private:
    string m_name;
    string m_type;
    size_t m_offset;
};

}
}

  类成员函数的反射：

 ClassMethod.h：

#pragma once

#include <string>
using namespace std;

namespace yazi {
namespace reflect {

class ClassMethod
{
public:
    ClassMethod() : m_name(""), m_method(0) {}
    ClassMethod(const string & name, uintptr_t method) : m_name(name), m_method(method) {}
    ~ClassMethod() {}

    const string & name()
    {
        return m_name;
    }

    uintptr_t method()
    {
        return m_method;
    }

private:
    string m_name;
    uintptr_t m_method;
};

}
}

      

C++实现反射（Reflection）
游戏技术？johnson3d的专栏不谈技术
03-28 1万+
C++实现Reflection最近1年多，我一直在琢磨和大量使用cli来开发游戏项目，.net系统的反射系统给我的开发设计思路，带来了很大的冲击。反射真的可以从根本上，让设计思路相对传统开发模式有很大的改变。但是反射通常都提供在类似java等动态语言上，后来ms在.net平台上推出了一个很强大完善的反射机制，我最近1年多的项目都是大量使用他，为我的项目开发，做出了很多有意思的东西。但是我的vi
C++ 反射机制（实例讲解）
那年聪聪
10-27 7958
C++反射机制
在C++上实现反射用法
lovely_yoshino的博客
11-10 1万+
最近看很多端到端的工作，发现大多数都是基于mmdet3d来做的，而这个里面用的比较多的形式就是反射机制，这样其实可以比较好的通过类似plugin的形式完成模型模块的插入。当然我们这里不是来分析python的反射机制的。我们这篇文章主要来介绍C++上实现反射。
玩转出花样！C++26 反射实现关键字参数的奇妙之旅
最新发布
2401_86652632的博客
02-13 628
具体实现时，首先要解析字符串化的捕获列表，创建数据成员规范，将 lambda 闭包的每个非静态数据成员与其对应的名称关联起来，然后注入关键字参数容器类型。多年来，命名参数、带标签参数或者说关键字参数的提议层出不穷，像 n4172、p1229、p0671 等提案，都在尝试解决这个问题，但可惜的是，这些提案都没有被最终采纳。今天，咱们就一起深入研究一下如何利用 C++26 中备受期待的反射特性，来实现顺序无关的关键字参数，这一过程不仅能让我们感受到 C++ 的强大魅力，还能为日常编程带来更多便利和乐趣。
C++ 中的反射
逍遥剑客
04-08 1916
 http://msdn.microsoft.com/zh-cn/library/y0114hz2.aspx 更新：2007 年 11 月反射允许在运行时检查已知数据类型。例如，反射允许使用给定程序集中的数据类型的枚举，并且可以发现给定类或值类型中的成员。无论类型是否已知或者在编译时被引用，都是如此。这使反射成为开发和代码管理工具的一项有用功能。请注意，所提供的程序
C++ 的“反射”技术
cyt的专栏
03-03 1242
Lit Window Library来自http://sourceforge.net/projects/litwindow 大概看了一下，使用了宏建立了一个比较复杂的数据结构，用来提供成员反查以及成员访问。 tinybind来自http://sourceforge.net/projects/tinybind/  这个应该不算是反射，不过通过了定义一个Binding函数实现成员和XML的Elemen
在C++实现反射
fly_on_grass的专栏
10-23 490
反射这个特性在C++中是没有的。所谓反射，自己的认为就是通过一个名字就可创建、调用、获取信息等一系列的操作，这个在脚本语言里面是比较常见的，COM组件也类似，知道个ID名，就可以做很多的工作了。 看看JAVA中的描述： JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法；这种动态获取的信息以及动态调用对象的方法的功能称
我所理解的 C++ 反射机制
热门推荐
Dablelv 的博客专栏。
06-17 3万+
在实际的项目中，听师兄说项目中用到了 C++ 反射，出于好奇，就查阅相关资料，发现强大的 C++ 本身并不支持反射，反而 Java 支持反射机制。当我得知这个事实时，唯 C++ 马首是瞻的我，心中暗自落泪，悲叹不已。但是，C++ 的拥趸们别难受，强大的 C++ 本身不支持，但却可以让我们手动实现，真的是曲径通幽处，禅房花木深。C++ 是不会辜负我们对它至死不渝的追逐。但是，说到 Java 的反射机制或者 C++ 用到了反射，如果没有真正的在项目中使用过，我们对它会感觉到陌生和不解。
C++反射机制实现
03-21
在讨论C++反射机制实现的过程中，我们首先需要明确反射机制的概念和分类。反射的定义源自人工智能领域，它主要涉及到两种反射结构：结构反射和计算反射。结构反射侧重于元类与类之间的关系，计算反射则关注于计算...
reflect:C++ 反射框架（为了好玩）
07-13
C++ 反射框架（为了好玩） 简单的例子： # include int main () { rf:: class_t clss = rf::class_t::for_name ( " hello_t " ); rf:: object_t object = clss. new_instance (); rf:: method_t method = clss...
C++ 反射机制详解及实例代码
08-31
需要注意的是，C++反射的实现往往伴随着一定的性能开销，因此在不需要高度动态性的场景下，应谨慎使用。此外，C++20标准引入了模块（Modules）和概念（Concepts）等特性，可能会为未来的反射支持打下基础，但目前...
C++ reflect 反射
01-28
C++ 实现的简单反射示例应用，可以实现类对象的方法的调用
c++ 反射
PI2024的专栏
06-10 4436
转至：https://cloud.tencent.com/developer/article/1524775 本文不讨论完整的C++反射技术，只讨论结构体 (struct)的字段 (field)反射，及其在序列化/反序列化代码生成上的应用。 正文开始于§ 静态反射部分，其他部分都是铺垫，可以略读。 打包后的代码可以通过 archived.zip下载，每个.cc文件上都有对应的编译、运行脚本，或者可以通过run_all.sh脚本运行所有代码。 1. 背景 很多人喜...
c++实现反射功能
itnkcong的博客
05-08 2529
这是一个无入侵的，并且带有反射代码生成工具的开源库。程序员一般都很懒，能自动实现的一般不想逐行敲代码，我们需要一个自动生成反射代码的工具，在这个开源库中，提供了一种基于llvm+clang进行代码生成的工具，在我们程序代码中只需要把需要反射的成员、函数打上下面的标记，利用反射工具就可以自动生成代码。反射工具会分析头文件，由于反射工具的REF_EXPORT_FLAG宏是生效的， 因此它看到标记了需要反射的成员前面都会多出了一个特殊的struct，基于此就可以把需要反射的信息提取出来，并生成我们需要的代码。
C++实现反射
liuyidang的专栏
04-03 206
天生限制 C++语言本身不支持反射机制，但C++对象总是要序列化的，序列化就是存储到磁盘上，将对象变成一定格式的二进制编码，然后要用的时候再将保存在磁盘上的二进制编码转化成一个内存中的对象，这个过程中总是需要有一个指示来告诉编译器要生成什么样的对象，最简单的方式当然就是类名了，例如：将一个ClassXXX对象存储到磁盘上，再从磁盘读取的时候让编译器根据“ClassXXX”名称来new一个对象。 ...
C++反射（Reflection）
PI2024的专栏
10-21 3419
库：boost.hana boost.PFR https://www.cnblogs.com/zengkefu/p/6724323.html An Introduction to Reflection in C++ Apr 13, 2017 Stop me if you’ve heard this one before. You are working on a messaging middleware, a game engine, a UI library, or any ot...
C++ 反射机制
yhc166188的博客
10-25 1161
反射机制：反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法和属性；这种动态获取的信息以及动态调用对象的方法的功能称为语言的反射机制。 Reflection 是 Java 程序开发语言的特征之一，它允许运行中的 Java 程序对自身进行检查，或者说”自审”，并能直接操作程序的内部属性。即可以在运行时加载、探知、使用编译期间完全未...
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包

打赏作者

水火汪

你的鼓励将是我创作的最大动力

¥1 ¥2 ¥4 ¥6 ¥10 ¥20
扫码支付：¥1
获取中
扫码支付

您的余额不足，请更换扫码支付或充值

打赏作者

实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

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

余额充值