c++反射的实现

已于 2024-07-06 22:04:00 修改
阅读量366 收藏 4
点赞数 2
文章标签： c++ 开发语言
于 2024-06-26 16:08:10 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/yangyin007/article/details/139992021
版权

最直观的使用：通过类的名称、函数名称、变量名称来实现创建类、调用类函数、获取与修改类参数。

通过反射创建类

思路：使用工厂类来创建对应的类，这个工厂使用ClassMap 来保存每个类对应的创建函数。

  • 通过RegisterClass 向 mClassMap 中存储创建函数
  • 通过CreateClass 来查找并调用className 对应的创建函数CreateObject()
typedef Object* (*createObject)(void);

class ClassFactory final
{
    friend class Singleton<ClassFactory>; // 工厂类的单例
public:
    // 注册每个类的创建函数
    void RegisterClass(const std::string& className, createObject method);

    // 创建指定的类对象
    Object* CreateClass(const std::string& className);

protected:
     ClassFactory() = default;
    virtual ~ClassFactory() = default;

    ClassFactory(const ClassFactory& other) = delete;
    ClassFactory(ClassFactory&& other) noexcept = delete;
    ClassFactory& operator=(const ClassFactory& other) = delete;
    ClassFactory& operator=(ClassFactory&& other) noexcept = delete;
private:
    std::map<std::string, createObject> mClassMap; // ClassName -> create class object function
};

void ClassFactory::RegisterClass(const std::string& className, createObject method)
{
    mClassMap[className] = method;
}

Object* ClassFactory::CreateClass(const std::string& className)
{
    auto it = mClassMap.find(className);
    if (it == mClassMap.end() )
    {
        return nullptr;
    }
    return mClassMap[className]();
}

这个类创建工厂应该是全局唯一的，所以使用了单例模板

template<typename T, bool is_thread_safe = true>
class Singleton
{
public:
    static T* Instance()
    {
        if (!is_thread_safe)
        {
            if (!mInstance)
            {
                mInstance = new T();
            }
        }
        else
        {
            if (!mInstance)
            {
                std::lock_guard<std::mutex> unique_locker(mMutex);
                if (!mInstance)
                {
                    mInstance = new T();
                }
            }
        }
        return mInstance;
    }

    Singleton(const Singleton& other) = delete;
    Singleton& operator=(const Singleton& other) = delete;

protected:
    Singleton() = default;
    virtual ~Singleton() = default;

private:
    static T* mInstance;
    static std::mutex mMutex;
};

template<typename T, bool is_thread_safe>
T* Singleton<T, is_thread_safe>::mInstance;

template<typename T, bool is_thread_safe>
std::mutex Singleton<T, is_thread_safe>::mMutex;

可以看到CreateClass 的返回值为Object* ，Obejct 为所有需要使用c++反射的类的基类。

class Object
{
public:
    void SetClassName(const std::string& className)
    {
        mClassName = className;
    }

    /**
     * 测试用函数
     */
    void showClassName() const
    {
        std::cout << mClassName << std::endl;
    }
public:
    std::string mClassName;
};

之后每个需要通过反射创建的类，只需要继承Obejct 即可。同时，为了向ClassFactory 中注册每个类的信息，还需要一个注册宏来帮助每个类快捷的注册

class ClassRegister
{
public:
    // 通过构造函数来向工厂中注册类的信息
    ClassRegister(const std::string& className, createObject method)
    {
        Singleton<ClassFactory>::Instance()->RegisterClass(className, method);
    }
};

// 用于注册类的宏
#define REGISTER_CLASS(className)           \
    Object* createObject##className()       \
    {                                       \
        Object* obj = new className();      \
        obj->SetClassName(#className);    \
        return obj;                         \
    }                                       \
    ClassRegister classRegister##className(#className, createObject##className)

有了上面几个类之后，就可以快捷的创建可以用于反射创建的类

class A :public Object
{
};

REGISTER_CLASS(A);


class B : public Object
{
};

REGISTER_CLASS(B);

执行测试程序

int main(int argc, char* argv[])
{
    ClassFactory * factory = Singleton<ClassFactory>::Instance();
    Object* o1 = factory->CreateClass("A");
    o1->showClassName();
    Object* o2 = factory->CreateClass("B");
    o2->showClassName();
    return 0;
}

执行结果为

A
B
// 结果正确，已经可以通过反射实现类的创建

通过反射调用类的函数

定义一个保存类成员函数信息的类

class ClassMethod
{
public:
    ClassMethod() = default;
    ~ClassMethod() = default;
    ClassMethod(const std::string& name, uintptr_t method) : mName(name), mMethod(method){}

    const std::string& Name() {return mName;}
    const uintptr_t Method() {return mMethod;}

private:
    std::string mName;
    uintptr_t mMethod;
};

扩展ClassFactory来保存ClassMethod信息

// ClassFactory.h
class ClassFactory final
{
public:
    // 为className注册method
    void RegisterClassMethod(const std::string& className, ClassMethod* method);

    // 获取className类有多少个注册函数
    size_t GetClassMethodCount(const std::string& className);
    // 获取className在pos上对的函数
    ClassMethod* GetClassMethod(const std::string& className, size_t pos);
    // 获取className中methodName方法
    ClassMethod* GetClassMethod(const std::string& className, const std::string& methodName);
private:
    std::map<std::string, std::vector<ClassMethod*>> mClassMethods; // className -> classMethod
};

// ClassFactory.cpp
 
void ClassFactory::RegisterClassMethod(const std::string& className, ClassMethod* method)
{
    mClassMethods[className].push_back(method);
}

size_t ClassFactory::GetClassMethodCount(const std::string& className)
{
    return mClassMethods[className].size();
}

ClassMethod* ClassFactory::GetClassMethod(const std::string& className, size_t pos)
{
    const std::vector<ClassMethod*>& methods = mClassMethods[className];
    if (pos < 0 || pos >= methods.size())
    {
        return nullptr;
    }

    return methods[pos];
}

ClassMethod* ClassFactory::GetClassMethod(const std::string& className, const std::string& methodName)
{
    for (auto method : mClassMethods[className])
    {
        if (method->Name()._Equal(methodName))
        {
            return method;
        }
    }
    return nullptr;
}

扩展classRegister来注册ClassMethod信息

// ClassRegister.h
class ClassRegister
{
public:
    ClassRegister(const std::string& className, const std::string& methodName, uintptr_t method)
    {
        ClassFactory* factory = Singleton<ClassFactory>::Instance();
        factory->RegisterClassMethod(className, new ClassMethod(methodName, method));
    }
};

// 用于注册类成员函数的宏
#define REGISTER_CLASS_METHOD(className, methodName)    \
    std::function<void(className*)> className##methodName##method = &className::methodName; \
    ClassRegister classRegister##className##methodName(#className, #methodName, (uintptr_t)&(className##methodName##method))

扩展Object来通过反射方法调用ClassMethod

// Object.h
class Object
{
public:
void CallMethod(const std::string& methodName);
};

// Object.cpp
void Object::CallMethod(const std::string& methodName)
{
    ClassFactory* factory = Singleton<ClassFactory>::Instance();
    ClassMethod* classMethod = factory->GetClassMethod(mClassName, methodName);

    typedef std::function<void(decltype(this))> ClassFunctiuon;
    (*reinterpret_cast<ClassFunctiuon*>(classMethod->Method()))(this);
}

验证

class A :public Object
{
public:
    int ANum = 3;
    std::string AString = "this is a a test";
    std::vector<int> mVector;

    void pa()
    {
        std::cout << "this is a pa function" << std::endl;
    }
};
REGISTER_CLASS(A);
REGISTER_CLASS_METHOD(A, pa);

class B : public Object
{
public:

    int BNum = 2;
    std::string BString = "this is a b test";

    void pb()
    {
        std::cout << "this is a pb function" << std::endl;
    }
};
REGISTER_CLASS(B);
REGISTER_CLASS_METHOD(B, pb);

int main(int argc, char* argv[])
{
    ClassFactory* factory = Singleton<ClassFactory>::Instance();
    Object* a = factory->CreateClass("A");
    Object* b = factory->CreateClass("B");
    a->CallMethod("pa");
    b->CallMethod("pb");
}

结果为

this is a pa function
this is a pb function
// 结果正确，成功调用了方法

通过反射访问类的参数

如何直接访问一个类的参数呢，通过类的指针偏移，获取参数的地址，就可以访问了。所以这部分主要需要做的就是将类参数的指针偏移以及类型保存下来。

这里指针偏移可以直接调用标准库

class Test
{
int a = 0;
}

size_t offset = offsetof(Test, a); // 获取参数a的指针偏移

// 标准库内的定义
#if defined _MSC_VER && !defined _CRT_USE_BUILTIN_OFFSETOF
    #ifdef __cplusplus
        #define offsetof(s,m) ((::size_t)&reinterpret_cast<char const volatile&>((((s*)0)->m)))
    #else
        #define offsetof(s,m) ((size_t)&(((s*)0)->m))
    #endif
#else
    #define offsetof(s,m) __builtin_offsetof(s,m)
#endif

定义一个保存参数反射所需属性的类ClassFiled

// 记录类参数的反射信息
class ClassFiled
{
public:
    ClassFiled() = default;
    explicit  ClassFiled(const std::string& name, const std::string& type, size_t offset) : mName(name), mType(type), mOffset(offset){}
    virtual ~ClassFiled() = default;

    const std::string& Name() const {return mName;}
    const std::string& Type() const {return mType;}
    const size_t& Offset() const {return mOffset;}
private:
    std::string mName = "";
    std::string mType = "";
    size_t mOffset = 0;
};

拓展ClassFactory

// ClassFactory.h
class ClassFactory final
{
public:
    // 为className类注册字段
    void RegisterClassFiled(const std::string& className, ClassFiled* filed);

    // 获取className类有多少个注册的参数
    size_t GetFiledCount(const std::string& className);
    // 获取className类指定位置的参数信息
    ClassFiled* GetFiled(const std::string& className, size_t pos);
    // 获取className类的 filedName 参数
    ClassFiled* GetFiled(const std::string& className, const std::string& filedName);
    
private:
    std::map<std::string, std::vector<ClassFiled*>> mClassFileds; // className -> classFileds
};

// ClassFactory.cpp
void ClassFactory::RegisterClassFiled(const std::string& className, ClassFiled* filed)
{
    mClassFileds[className].push_back(filed);
}

size_t ClassFactory::GetFiledCount(const std::string& className)
{
    return mClassFileds[className].size();
}

ClassFiled* ClassFactory::GetFiled(const std::string& className, size_t pos)
{
    size_t len = mClassFileds[className].size();
    if (pos < 0 || len <= pos)
    {
        return nullptr;
    }
    return mClassFileds[className][pos];
}

ClassFiled* ClassFactory::GetFiled(const std::string& className, const std::string& filedName)
{
    for (auto filed : mClassFileds[className])
    {
        if (filed->Name()._Equal(filedName))
        {
            return filed;
        }
    }
    return nullptr;
}

扩展ClassRegister

class ClassRegister
{
public:
    ClassRegister(const std::string& className, const std::string& filedName, const std::string& filedType, size_t offset)
    {
        ClassFactory* factory = Singleton<ClassFactory>::Instance();
        factory->RegisterClassFiled(className, new ClassFiled(filedName, filedType, offset));
    }
};

// 用于注册类参数的宏
#define REGISTER_CLASS_PARAMETER(className, filedName, type)    \
    ClassRegister classRegister##className##filedName(#className, #filedName, #type, offsetof(className, filedName))

扩展Object

// Object.h
class Object
{
public:
    template<typename T>
    void Set(const std::string& filedName, const T& value);
    
    template<typename T>
    void Get(const std::string& filedName, T& value);
};

// ClassFactory.h
template <typename T>
void Object::Set(const std::string& filedName, const T& value)
{
    ClassFactory* factory = Singleton<ClassFactory>::Instance();
    ClassFiled* filed = factory->GetFiled(mClassName, filedName);
    *reinterpret_cast<T*>((size_t)this + filed->Offset()) = value;
}

template <typename T>
void Object::Get(const std::string& filedName, T& value)
{
    ClassFactory* factory = Singleton<ClassFactory>::Instance();
    ClassFiled* filed = factory->GetFiled(mClassName, filedName);
    value = *reinterpret_cast<T*>((size_t)this + filed->Offset());
}

验证

class A :public Object
{
public:
    int ANum = 3;
    std::string AString = "this is a a test";
    std::vector<int> mVector;
};

REGISTER_CLASS(A);
REGISTER_CLASS_PARAMETER(A, ANum, int);
REGISTER_CLASS_PARAMETER(A, AString, string);
REGISTER_CLASS_PARAMETER(A, mVector, vector<int>);

class B : public Object
{
public:

    int BNum = 2;
    std::string BString = "this is a b test";
};

REGISTER_CLASS(B);
REGISTER_CLASS_PARAMETER(B, BNum, int);
REGISTER_CLASS_PARAMETER(B, BString, string);


int main(int argc, char* argv[])
{
    ClassFactory * factory = Singleton<ClassFactory>::Instance();
    Object* o1 = factory->CreateClass("A");
    o1->showClassName();
    size_t num = 0;
    string name = "";
    vector<int> vec;
    o1->Get("ANum", num);
    o1->Get("AString", name);
    o1->Get("mVector", vec);
    cout << num << "\t" << name << endl;
    for (auto value : vec)
    {
        cout << value << endl;
    }
    o1->Set("ANum", 17);
    o1->Set("AString", string("kk"));
    o1->Set("mVector", vector<int>(3, 6));
    o1->Get("ANum", num);
    o1->Get("AString", name);
    o1->Get("mVector", vec);
    cout << num << "\t" << name << endl;
    for (auto value : vec)
    {
        cout << value << endl;
    }

    
    Object* o2 = factory->CreateClass("B");
    o2->Get("BNum", num);
    o2->Get("BString", name);
    o2->showClassName();
    cout << num << "\t" << name << endl;
}

执行结果如下，说明已经可以通过反射来控制参数

A
3       this is a a test
17      kk
6
6
6
B
2       this is a b test
奇华智能
关注
通过C++反射实现C++与任意脚本（lua、js等）的交互（一）
05-20 742
C++的反射机制 C++语言本身是不支持反射机制的，但是我们可以通过一些特殊的手段来实现反射机制。 反射的核心是在于能运行时获取数据的类型信息，总所周知，C++是编译型语言，完整的类型信息只存在于编译时（部分类型信息在开启RTTI后可以在运行时获取），如果要实现完整的反射，只能是基于编译时所产生的数据。通常在标准C++编译器下实现的方式会有以下几种： 一、基于编译产生的调试信息，例如解析pdb文件 二、通过编译器之外的工具分析源文件，获取对应信息 三、通过在代码中嵌入宏来收集相关信息...
深入探讨C++的高级反射机制
hebhljdx的博客
06-26 2606
反射是一种编程语言能力，允许程序在运行时查询和操纵对象的类型信息。它广泛应用于对象序列化、远程过程调用、测试框架、和依赖注入等场景。 由于C++语言本身的反射能力比较弱，因此C++生态种出现了许多有趣的反射库和实现思路。我们在本文一起探讨其中的奥秘。
C++反射的实现方式
GodJhin的博客
07-10 1140
在C++中，反射（reflection）通常是指在运行时检查或修改程序结构的能力，比如类型、对象、方法、属性等。与许多动态语言（如Python、JavaScript）不同，C++是一种静态类型的编译语言，缺乏内置的反射机制。RTTI（Run-Time Type Information）是C++的一部分，用于在运行时识别类型。C++虽然没有内置的反射机制，但通过使用RTTI、宏和模板以及第三方库（如RTTR），我们可以实现类似的反射功能。通过使用宏和模板，可以创建一个简单的反射系统。使用RTTR库的示例。
C++动态反射第二版
最新发布
m0_56662207的博客
08-28 267
C++ 动态反射第二版
C++ reflect 反射
01-28
C++ 实现的简单反射示例应用，可以实现类对象的方法的调用
在C++实现反射
fly_on_grass的专栏
10-23 427
反射这个特性在C++中是没有的。所谓反射，自己的认为就是通过一个名字就可创建、调用、获取信息等一系列的操作，这个在脚本语言里面是比较常见的，COM组件也类似，知道个ID名，就可以做很多的工作了。 看看JAVA中的描述： JAVA反射机制是在运行状态中，对于任意一个类，都能够知道这个类的所有属性和方法；对于任意一个对象，都能够调用它的任意一个方法；这种动态获取的信息以及动态调用对象的方法的功能称
c++实现反射功能
itnkcong的博客
05-08 2209
这是一个无入侵的，并且带有反射代码生成工具的开源库。程序员一般都很懒，能自动实现的一般不想逐行敲代码，我们需要一个自动生成反射代码的工具，在这个开源库中，提供了一种基于llvm+clang进行代码生成的工具，在我们程序代码中只需要把需要反射的成员、函数打上下面的标记，利用反射工具就可以自动生成代码。反射工具会分析头文件，由于反射工具的REF_EXPORT_FLAG宏是生效的， 因此它看到标记了需要反射的成员前面都会多出了一个特殊的struct，基于此就可以把需要反射的信息提取出来，并生成我们需要的代码。
C++实现反射机制
bingo_qiu的专栏
05-10 472
C++本身是不支持反射机制的，而在最近项目中很多地方用到了工厂类，这样就增加了代码中分支语句，降低了代码的可读性，于是就模仿C#中的反射机制，用函数指针自己实现了C++的反射。下面是实现时写的demo介绍。主要特点有以下几点：用map保存了字符串到动态类生成的函数指针的映射。使用类名注册，根据不同的类名字符串构造成不同的类对象。代码实例：Singleton类头文件 1 #pragma once ...
C++实现反射
野生的声威的专栏
01-12 6601
前言 首先，C++不同于C#或者Java，没有自带反射机制，只能通过C++一些传统艺能变着法地实现。 有哪些反射 1、类对象反射：简单地说就是程序运行时读进来一个字符串，然后程序就会自动创建出字符串对应名字的类对象 2、类属性反射：能够遍历得到类的所有成员，知道它们的数据类型和名字。最实际的例子就是Unreal和Unity中UI的实现，当定义一个类成员变量时，它就能在UI中显示出来。而不需...
c++ 反射实现原理代码；
09-24
c++ 反射实现原理代码；c++ 反射实现原理代码；c++ 反射实现原理代码；c++ 反射实现原理代码；c++ 反射实现原理代码；
C++反射机制实现
03-21
在讨论C++反射机制实现的过程中，我们首先需要明确反射机制的概念和分类。反射的定义源自人工智能领域，它主要涉及到两种反射结构：结构反射和计算反射。结构反射侧重于元类与类之间的关系，计算反射则关注于计算...
C++ 反射实现
cz168love的专栏
06-18 709
在看《大话设计模式》的策略模式中，
通过C++反射实现C++与任意脚本（lua、js等）的交互（二）
05-20 499
C++对象模型（上） 要实现完善的C++反射机制，我们需要深入了解C++的对象模型。但是很遗憾，C++标准并没有明确规定C++对象模型，而是把这个自由度交给了编译器，不同的编译器下产生的对象并不一定是二进制兼容的。不过比较幸运的是主流的编译器实现的方式都大同小异，而且，我们很多时候并不一定需要深入到编译结果，通过宏和模板就能解决大部分的问题。 一、全局函数 全局函数（或者静态函数）是比较容易通过模板获取到函数类型信息的，通过一个模板函数就可以： template< typename...
C++反射的实现
brightlee`s blog
06-06 9468
前言反射的概念： 指程序在运行时，访问、检测和修改它本身状态或行为的一种能力。wikipedia 简单的来说，就是一种自描述和自控制的能力。如果联想到镜子，就可以很好的理解，你能通过镜子看到自己，包括自己的动作，自己的外表。唯一不同的地方是，计算机语言的反射能力还包含对看到的自己采取措施。反射的作用在计算机编程语言中，反射机制可以用来： 获取类型的信息，包括属性、方法 动态调用方法 动态构造对象
C++ 中的反射
逍遥剑客
04-08 1876
 http://msdn.microsoft.com/zh-cn/library/y0114hz2.aspx 更新：2007 年 11 月反射允许在运行时检查已知数据类型。例如，反射允许使用给定程序集中的数据类型的枚举，并且可以发现给定类或值类型中的成员。无论类型是否已知或者在编译时被引用，都是如此。这使反射成为开发和代码管理工具的一项有用功能。请注意，所提供的程序
C++ 实现反射
xiangxianghehe的博客
12-01 760
代码出处：https://wandbox.org/permlink/cnCyacn84LAWjeSG。原理讲解：c++如何实现反射功能？编译器环境：clang version 5.0.0 (tags/RELEASE_500/final) Target: x86_64-pc-windows-msvc Thread model: posix编译命令：clang++ test.cpp -Wall -Wex
c++ 反射
PI2024的专栏
06-10 4305
转至：https://cloud.tencent.com/developer/article/1524775 本文不讨论完整的C++反射技术，只讨论结构体 (struct)的字段 (field)反射，及其在序列化/反序列化代码生成上的应用。 正文开始于§ 静态反射部分，其他部分都是铺垫，可以略读。 打包后的代码可以通过 archived.zip下载，每个.cc文件上都有对应的编译、运行脚本，或者可以通过run_all.sh脚本运行所有代码。 1. 背景 很多人喜...
C++反射机制实现与对象序列化
C++反射机制的必要性： 反射机制在某些场景下非常有用，如对象序列化、插件系统、动态加载模块和元数据操作。在C++中，虽然有RTTI（运行时类型识别）提供部分功能，如`dynamic_cast`和`typeid`，但它们无法提供与...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

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

抵扣说明：

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

余额充值