c++实现反射功能

最新推荐文章于 2025-07-12 21:26:08 发布

原创最新推荐文章于 2025-07-12 21:26:08 发布 · 2.7k 阅读

25 ·

CC 4.0 BY-SA版权

文章标签：

#c++ #开发语言

部署运行你感兴趣的模型镜像

搬运自己知乎文章：c++如何实现反射功能？ - 知乎

c++的反射目前需要自行实现，核心思路就是把需要反射的class（struct）的成员、方法、构造函数等元数据通过数据结构描述出来，这些元数据可以在程序启动时构造出来存储在全局静态变量中。我们使用反射时通过名称或者类型查找到这些元数据，就可以new对象或者alloca对象，使用字符串查找到对象的成员或者方法，结合对象的指针再去访问他们。

以下内容都在https://github.com/laiyongcong/cppfoundation 中可找到详细实现。这是一个无入侵的，并且带有反射代码生成工具的开源库。结合CMake使用反射工具可以完全不需要手写任何额外的反射代码，此外，该开源库包含基于反射的json处理、csv文件读写（老游戏策划喜欢填表，这里加个狗头）、无锁的多线程框架和日志框架等。

下面简单讲述一下实现反射的基本原理，没有使用c++的奇怪的高级特性，甚至新手也能比较容易看懂。支持c++11的编译器就可以编译工程。

成员变量的描述是最简单的，一般包含以下信息：类型、offset、size、元素类型（数组情形）、数量（数组情形），以下是反射库的关于成员变量的描述：

class Field : public MemberBase {
  friend class Class;
  friend struct FieldRegister;

 private:
  const std::type_info& mType;
  const std::type_info& mElementType; //for ArrayType
  uint64_t mOffset;
  std::size_t mSize;
  int mElementCount; //for array type
  int mFieldIdx;     //field index in Class

  public:
   FORCEINLINE const std::type_info& GetType() const { return mType; }
   FORCEINLINE const std::type_info& GetElementType() const { return mElementType; }
   FORCEINLINE std::size_t GetSize() const { return mSize; }
   FORCEINLINE bool IsArray() const { return mType != mElementType; }
   FORCEINLINE int GetElementCount() const { return mElementCount; }
   FORCEINLINE int GetFieldIdx() const { return mFieldIdx; }
   FORCEINLINE uint64_t GetOffset() const { return mOffset; }

   template <typename Object, typename Value>
   void Get(const Object* object, Value& result) const;

   template <typename Object, typename Value>
   void GetPtr(const Object* object, Value*& result) const;

   template <typename Object, typename Value>
   void GetByIdx(const Object* pObj, Value& result, int idx = 0) const;

   template <typename Object, typename Value>
   void GetPtrByIdx(const Object* pObj, Value*& result, int idx = 0) const;

   template <typename Object, typename Value>
   void Set(Object* object, const Value& value) const;

   template <typename Object, typename Value>
   void SetByIdx(Object* object, const Value& value, int idx = 0) const;

  private:
   Field(uint64_t offset, std::size_t size, const std::type_info& type, const std::type_info& elementType, const Class* pClass, EnumAccessType accessType, const char* strType, const char* strName,
         int nElementCount);
};

在反射数组时，需要推导数组的元素个数，当我们需要把一个类的成员变量反射时，一般的反射函数会这样写：

template <typename F>
void RefField(const F T::* fieldptr, const char* szName){
……
}

这里F代表成员的类型，T就是需要反射的class（struct），F如果是一个数组，表面上看我们很难得到其元素的类型和元素的个数，为了得到这些信息我们需要把它定义出来：

 static char szTmpBuff[sizeof(F)];
 F* pField = (F*)szTmpBuff;

我们得到了一个F类型的实例，接下来我们需要利用模版进行推导元素的类型以及数量（可能有其他方法）：

struct FieldInfo {
  const std::type_info& mElementType;
  int mElementCount;
  FieldInfo(int nCount, const std::type_info& type) : mElementType(type), mElementCount(nCount){}
};

template <typename F, int N>
FieldInfo GetFieldInfo(F (&c)[N]) {
  return FieldInfo(N, typeid(F));
}
template <typename F>
FieldInfo GetFieldInfo(F(&c)) {
  return FieldInfo(1, typeid(F));
}

....

//此时我们只需要调用GetFieldInfo就可以得到元素的类型以及数量
FieldInfo fInfo = GetFieldInfo(*pField);

成员函数和构造函数的描述复杂一些，因函数的返回值，参数表等都是不确定的，需要进行模版推导，首先我们需要对一个参数列表进行推导，以获得函数的参数列表信息：

template<typename T, typename... Args>
struct ArgsHelper {
  static void ListArgs(TypeList& argList) {
    if (typeid(T) != typeid(void)) argList.push_back(&typeid(T));
    ArgsHelper<Args...>::ListArgs(argList);
  }
};

template <typename T>
struct ArgsHelper<T> {
  static void ListArgs(TypeList& argList) {
    if (typeid(T) != typeid(void)) argList.push_back(&typeid(T));
  }
};

然后我们需要对整个函数做一个基本的描述（函数都有返回值以及参数表）：

struct BaseCallable {
  virtual ~BaseCallable(){}
  virtual int32_t GetArgsCount() const = 0;
  virtual const TypeList& GetArgTypeList() const = 0;
  virtual const std::type_info& GetRetType() const = 0;
  virtual String GetArgsString() const = 0;
};

template <typename R, typename... Args>
struct Callable : public BaseCallable {
  TypeList ArgList;
  Callable() { ArgsHelper<Args...>::ListArgs(ArgList); }
  int32_t GetArgsCount() const override { return (int32_t)ArgList.size(); }
  virtual const TypeList& GetArgTypeList() const override { return ArgList; }
  virtual const std::type_info& GetRetType() const override { return typeid(R); }
  virtual String GetArgsString() const override {
    String strRes = "(";
    auto argsList = GetArgTypeList();
    auto it = argsList.begin();
    if (it != argsList.end()) {
      strRes += Demangle((*it)->name());
      it++;
    }
    for (; it != argsList.end(); it++) {
      strRes += ",";
      strRes += Demangle((*it)->name());
    }
    strRes += ")";
    return strRes;
  }
};
//空参数表情形
template <typename R>
struct Callable<R> : public BaseCallable {
  TypeList ArgList;
  Callable() {}
  int32_t GetArgsCount() const override { return 0; }
  virtual const TypeList& GetArgTypeList() const override { return ArgList; }
  virtual const std::type_info& GetRetType() const override { return typeid(R); }
  virtual String GetArgsString() const override { return "()"; }
};

在此基础上，我们继续对函数进行进一步的描述（带上调用方法），如果是静态函数，可以描述成以下的数据结构：

template <typename R, typename... Args>
struct StaticCallable : public Callable<R, Args...> {
  typedef R (*MethodType)(Args...);
  MethodType method;
  StaticCallable(MethodType m) : Callable<R, Args...>(), method(m) {}
  R invoke(Args... args) const { return method(args...); }
};

template <typename R>
struct StaticCallable<R> : public Callable<R> {
  typedef R (*MethodType)();
  MethodType method;
  StaticCallable(MethodType m) : Callable<R>(), method(m) {}
  R invoke() const { return method(); }
};

如果是class（struct）的成员函数，我们这样描述：

template <typename R, typename C, typename... Args>
struct MemberFuncCallable : public Callable<R, Args...> {
  typedef R (C::*MethodType)(Args...);
  MethodType method;
  MemberFuncCallable(MethodType m) : Callable<R, Args...>(), method(m) {}
  R invoke(C* object, Args... args) const { return (object->*method)(args...); }
};

template <typename R, typename C>
struct MemberFuncCallable<R, C> : public Callable<R> {
  typedef R (C::*MethodType)();
  MethodType method;
  MemberFuncCallable(MethodType m) : Callable<R>(), method(m) {}
  R invoke(C* object) const { return (object->*method)(); }
};

成员函数如果是常函数，我们也需要考虑，需要把函数指针类型换成typedef R (C::*MethodType)(Args...) const; 这里不展开。

至此，描述函数的Method除了其他描述性信息，关键的是需要存储一个BaseCallable指针，用该指针结合模版，正确地调用到目标函数，如下：

template <typename R, typename C, typename... Args>
R Method::Invoke(C* object, Args... args) const {
   typedef const MemberFuncCallable<R, C, Args...> CallableType;
   typedef const ConstMemberFuncCallable<R, C, Args...> ConstCallableType;
   CallableType* cb = dynamic_cast<CallableType*>(mCallable.get());
   if (cb) {
     return cb->invoke(object, args...);
   }
   ConstCallableType* constCb = dynamic_cast<ConstCallableType*>(mCallable.get());
   if (constCb) {
     return constCb->invoke(object, args...);
   }
   if (TestCompatible<Args...>(typeid(R), typeid(C), object, mIsVirtual)) {
     cb = (CallableType*)(mCallable.get());
     return cb->invoke(object, args...);
   }
   throw TypeMismatchError(GetLongIdentity() + ":\n" + FindMisMatchedInfo<Args...>(typeid(R), typeid(C)));
}

关于类的构造函数的反射以及在内存上alloca方法的反射，可以参考ReflictiveClass中的RefConstructor()方法，这里涉及推导构造函数，以及从构造函数推导alloca函数的过程。

我们已经有了描述代码中基本元数据的数据结构，我们需要一个描述一个class(struct)的数据结构：

class Class {
……
private:
 mutable std::atomic_int mFieldIdx;
 String mName;
 String mFullName;
 mutable const Class* mSuper;   //继承关系
 const SuperCastFuncPtr mSuperCastFunc;
 const SuperCastConstFuncPtr mSuperCastConstFunc;
 const std::type_info& mType;
 const std::type_info& mPtrType;

 FieldList mFields;
 FieldMap mFieldMap;
 StaticFieldList mStaticFieldList;
 StaticFieldMap mStaticFieldMap;
 MethodList mMethods;
 MethodMap mMethodMap;
 StaticMethodList mStaticMethods;
 StaticMethodMap mStaticMethodMap;
 ConstructorList mConstructors;
};

我们只需要把所有的Class管理起来，整个反射就具备了基本框架。如何便利地把需要反射的class（struct）注册到系统中，可以参考ReflectiveClass的实现，这里不展开。

程序员一般都很懒，能自动实现的一般不想逐行敲代码，我们需要一个自动生成反射代码的工具，在这个开源库中，提供了一种基于llvm+clang进行代码生成的工具，在我们程序代码中只需要把需要反射的成员、函数打上下面的标记，利用反射工具就可以自动生成代码。

#ifndef REF_EXPORT_FLAG
#  define REF_EXPORT
#else
#  define REF_EXPORT struct CPPFD_JOIN(__refflag_, __LINE__) {};
#endif

反射工具会分析头文件，由于反射工具的REF_EXPORT_FLAG宏是生效的，因此它看到标记了需要反射的成员前面都会多出了一个特殊的struct，基于此就可以把需要反射的信息提取出来，并生成我们需要的代码。

反射工具的源代码也在提供了，可以根据自己的项目进行扩展和修改。

您可能感兴趣的与本文相关的镜像

Seed-Coder-8B-Base

文本生成

Seed-Coder

Seed-Coder是一个功能强大、透明、参数高效的 8B 级开源代码模型系列，包括基础变体、指导变体和推理变体，由字节团队开源

5 条评论

优快云-Ada助手 2024.05.09
恭喜你开始了博客创作！实现反射功能是一个很有挑战性的主题，相信你在这方面已经有了一定的研究和实践经验。接下来，我建议你可以深入探讨反射功能的应用场景和实际项目中的应用案例，这样可以让读者更容易理解并将知识运用到实践中。希望你能继续保持热情，坚持原创创作，期待看到更多优质内容！推荐【每天值得看】：https://bbs.youkuaiyun.com/forums/csdnnews?typeId=21804&utm_source=csdn_ai_ada_blog_reply1

优快云-Ada助手 2024.05.09
恭喜你这篇博客进入【优快云每天最佳新人】榜单，全部的排名请看 https://bbs.youkuaiyun.com/topics/618645014。

优快云-Ada助手 2024.05.09
恭喜你这篇博客进入【优快云每天最佳新人】榜单，全部的排名请看 https://bbs.youkuaiyun.com/topics/618645014。

优快云-Ada助手 2024.05.09
恭喜你这篇博客进入【优快云每天最佳新人】榜单，全部的排名请看 https://bbs.youkuaiyun.com/topics/618644862。

优快云-Ada助手 2024.05.09
恭喜你这篇博客进入【优快云每天最佳新人】榜单，全部的排名请看 https://bbs.youkuaiyun.com/topics/618644862。