深入探讨C++的高级反射机制

反射是一种编程语言能力，允许程序在运行时查询和操纵对象的类型信息。它广泛应用于对象序列化、远程过程调用、测试框架、和依赖注入等场景。
由于C++语言本身的反射能力比较弱，因此C++生态种出现了许多有趣的反射库和实现思路。我们在本文一起探讨其中的奥秘。

反射实现类型

高级反射的两种实现思路分别是编译时反射和运行时反射。

编译时反射

编译时反射 (Compile-time Reflection) 在C++中通常依赖模板元编程来实现。这种反射在编译时确定类型信息，不需要动态类型识别 (RTTI)。这种方法的优点在于可以生成性能更优的代码，减小二进制文件的大小，因为所有的类型信息在编译时都已确定，不需要在运行时查询。

优点

性能：由于类型信息在编译时就已确定，可以避免运行时查找，从而提高性能。
二进制大小：不需要存储额外的类型信息，可以减小最终二进制文件的大小。
确定性：编译时反射的结果在编译完成后就已确定，这给程序的行为带来了确定性。

缺点

维护成本：需要手动注册每个需要反射的类型和成员，增加了代码的维护难度。
灵活性较差：程序一旦编译完成，无法改变其反射的行为。

实现原理

在C++中，编译时反射通常利用模板特化和宏定义来实现类型注册。
https://github.com/Ubpa/USRefl/tree/master库就是一个典型的编译时反射的库。
编译时反射库的使用往往需要入侵源码，下面是一个简单的使用TypeInfo特化来注册类型信息的示例：

struct Point {float x, y;
};template<>
struct TypeInfo<Point> : TypeInfoBase<Point> {static constexpr FieldList fields = {Field { "x", &Point::x },Field { "y", &Point::y }};
};

在这个例子中，我们为Point类型特化了TypeInfo模板类，定义了一个静态的fields字段列表，其中包含了Point结构体的成员变量。
下面是上面的编译时反射的使用示例，它演示了如何遍历Point结构体的字段：

TypeInfo<Point>::fields.ForEach([](const auto& field) {std::cout << field.name << std::endl;
});

如果需要不入侵源码，还有一种做法是通过代码预处理技术实现生成反射的类型信息，使用这种技术实现反射最著名的莫过于Qt的元反射机制和元对象编译器MOC。

Qt的反射机制

代码预处理技术通过预处理步骤生成或修改源代码，从而实现反射。
Qt框架通过一个称为Meta-Object Compiler (MOC)的元对象编译器来提供反射能力。MOC是一个代码预处理器，它在C++编译之前运行，扫描源代码中的特殊宏（如Q_OBJECT、signals、slots），并生成额外的C++代码，这些代码包含了类型信息和用于信号与槽机制的元信息。

例如，如果一个类需要使用Qt的信号和槽机制，则必须在类定义中包含Q_OBJECT宏：

#include <QObject>class MyClass : public QObject {Q_OBJECT
public:MyClass(QObject* parent = nullptr);virtual ~MyClass();signals:void mySignal();public slots:void mySlot();
};

MOC会识别Q_OBJECT宏，并为MyClass生成额外的C++代码文件，这个文件包含了反射需要的元信息。这些信息允许在运行时查询类的信号和槽，以及进行信号和槽之间的连接。

使用Qt的MOC技术，开发者可以在运行时执行类似如下的动态操作：

MyClass myObject;
QMetaObject::invokeMethod(&myObject, "mySlot");

上述代码将在运行时调用mySlot槽函数，而不需要在编译时知道该槽的存在。

代码预处理的优势和挑战

代码预处理技术的优势在于它能够在不改变C++语言本身的情况下实现反射。这种方法灵活且与编译器无关，可以跨平台使用。

然而，这种技术也有其挑战和缺点：

额外的构建步骤：需要在编译前运行预处理器，这使得构建过程更复杂。
开发工具的兼容性：一些集成开发环境（IDE）和代码编辑器可能需要特殊配置或插件来支持这种预处理步骤。
额外的学习成本：开发者需要学习额外的宏和注解方式，这增加了学习和使用框架的难度。

虽然C++标准不直接支持反射，但通过编译器扩展和代码预处理技术，开发者们仍然能够在C++中实现类似反射的功能。这些技术在实践中证明了其有效性，并在许多项目中得到了成功的应用。

运行时反射

运行时反射 (Runtime Reflection) 是许多动态语言（如Python、Java和C#）的标准功能。C++的RTTI提供了有限的运行时反射能力，例如通过typeid和dynamic_cast获取类型信息和进行类型转换。

优点

灵活性：可以在程序运行时查询和操纵类型信息，为动态行为提供了可能。
自动化：大多数支持运行时反射的语言会自动处理类型信息的注册和管理。

缺点

性能开销：运行时查询类型信息需要时间，可能会影响性能。
二进制大小：需要存储额外的类型信息，增加了二进制文件的大小。

实现原理

运行时反射依靠语言运行时系统在内存中维护类型信息。在C++中，RTTI提供了typeid操作符来获取对象的类型信息：

Point p;
std::cout << typeid(p).name() << std::endl;

使用示例

在Java中，运行时反射的使用示例可能如下所示：

Class<?> clazz = Class.forName("java.lang.String");
Method[] methods = clazz.getDeclaredMethods();
for (Method method : methods) {System.out.println(method.getName());
}

C++为什么不直接支持一流的反射

C++作为一种静态类型语言，它的设计哲学强调性能和内存控制。直接支持运行时反射将违背这种设计哲学，因为运行时反射需要在内存中维护类型信息的数据结构，这会增加额外的内存和性能开销。

此外，C++的编译模型和链接模型也不适合直接支持反射。C++程序通常由多个翻译单元组成，它们在链接时才最终形成一个程序。这使得在编译时跨翻译单元维护类型信息变得困难。

C++的未来发展趋势

C++社区和标准委员会正在探索如何在未来的标准中增加反射的支持。最新的C++标准已经包含了一些反射相关的提案，比如静态反射，这表明C++正逐步朝着增强其反射能力的方向发展。

最后，一起实现一个最简单的C++编译时反射功能吧

编写一个最简单的C++编译时反射库涉及到模板元编程和一些宏定义。下面是一个非常基础的版本，这个反射库仅支持遍历字段名称和获取字段值。

#include <iostream>
#include <tuple>
#include <stdexcept>
#include <assert.h>
#include <string_view>
#include <optional>
#include <utility> // For std::forwardnamespace refl {// 这个宏用于创建字段信息
#define REFLECTABLE_PROPERTIES(TypeName, ...)  using CURRENT_TYPE_NAME = TypeName; \static constexpr auto properties() { return std::make_tuple(__VA_ARGS__); }
#define REFLECTABLE_MENBER_FUNCS(TypeName, ...) using CURRENT_TYPE_NAME = TypeName; \static constexpr auto member_funcs() { return std::make_tuple(__VA_ARGS__); }// 这个宏用于创建属性信息，并自动将字段名转换为字符串
#define REFLEC_PROPERTY(Name) refl::Property<decltype(&CURRENT_TYPE_NAME::Name), &CURRENT_TYPE_NAME::Name>(#Name)
#define REFLEC_FUNCTION(Func) refl::Function<decltype(&CURRENT_TYPE_NAME::Func), &CURRENT_TYPE_NAME::Func>(#Func)// 定义一个属性结构体，存储字段名称和值的指针template <typename T, T Value>struct Property {const char* name;constexpr Property(const char* name) : name(name) {}constexpr T get_value() const { return Value; }};template <typename T, T Value>struct Function {const char* name;constexpr Function(const char* name) : name(name) {}constexpr T get_func() const { return Value; }};// 用于获取特定成员的值的函数，如果找不到名称，则返回默认值template <typename T, typename Tuple, size_t N = 0, size_t RetTypeSize = 0>constexpr void* __get_field_value_impl(T& obj, const char* name, const Tuple& tp) {if constexpr (N >= std::tuple_size_v<Tuple>) {return nullptr;}else {const auto& prop = std::get<N>(tp);if (std::string_view(prop.name) == name) {assert(RetTypeSize == sizeof(prop.get_value()));// 返回值类型传错了return (void*)&(obj.*(prop.get_value()));}else {return __get_field_value_impl<T, Tuple, N + 1, RetTypeSize>(obj, name, tp);}}}template <typename RetType, typename T, typename Tuple, size_t N = 0>constexpr RetType* get_field_value(T& obj, const char* name, const Tuple& tp) {return (RetType*)__get_field_value_impl<T, Tuple, N, sizeof(RetType)>(obj, name, tp);}// 成员函数相关:template <typename RetType, typename T, typename FuncTuple, size_t N = 0, typename... Args>constexpr std::optional<RetType> __invoke_member_func_impl(T& obj, const char* name, const FuncTuple& tp, Args&&... args) {if constexpr (N >= std::tuple_size_v<FuncTuple>) {//throw std::runtime_error(std::string(name) + " Function not found."); // 可以选择抛出异常或者通过optional判断是否成功return std::optional<RetType>();}else {const auto& func = std::get<N>(tp);if (std::string_view(func.name) == name) {return (obj.*(func.get_func()))(std::forward<Args>(args)...);}else {return __invoke_member_func_impl<RetType, T, FuncTuple, N + 1>(obj, name, tp, std::forward<Args>(args)...);}}}template <typename RetType, typename T, typename... Args>constexpr std::optional <RetType> invoke_member_func(T& obj, const char* name, Args&&... args) {constexpr auto funcs = T::member_funcs();return __invoke_member_func_impl<RetType>(obj, name, funcs, std::forward<Args>(args)...);}// 定义一个类型特征模板，用于获取属性信息template <typename T>struct For {static_assert(std::is_class_v<T>, "Reflector requires a class type.");// 遍历所有字段名称template <typename Func>static void for_each_propertie_name(Func&& func) {constexpr auto props = T::properties();std::apply([&](auto... x) {((func(x.name)), ...);}, props);}// 遍历所有字段值template <typename Func>static void for_each_propertie_value(T& obj, Func&& func) {constexpr auto props = T::properties();std::apply([&](auto... x) {((func(x.name, obj.*(x.get_value()))), ...);}, props);}// 遍历所有函数名称template <typename Func>static void for_each_member_func_name(Func&& func) {constexpr auto props = T::member_funcs();std::apply([&](auto... x) {((func(x.name)), ...);}, props);}};}// namespace refl// =========================一下为使用示例代码====================================// 用户自定义的结构体，需要反射的字段使用REFLECTABLE宏来定义
struct MyStruct {int x{ 10 };float y{ 20.5f };int print() const {std::cout << "MyStruct::print called! " << "x: " << x << ", y: " << y << std::endl;return 666;}REFLECTABLE_PROPERTIES(MyStruct,REFLEC_PROPERTY(x),REFLEC_PROPERTY(y));REFLECTABLE_MENBER_FUNCS(MyStruct,REFLEC_FUNCTION(print));
};int main() {MyStruct obj;// 打印所有字段名称refl::For<MyStruct>::for_each_propertie_name([](const char* name) {std::cout << "Field name: " << name << std::endl;});// 打印所有字段值refl::For<MyStruct>::for_each_propertie_value(obj, [](const char* name, auto&& value) {std::cout << "Field " << name << " has value: " << value << std::endl;});// 打印所有函数名称refl::For<MyStruct>::for_each_member_func_name([](const char* name) {std::cout << "Member func name: " << name << std::endl;});// 获取特定成员的值，如果找不到成员，则返回默认值auto x_value = get_field_value<int>(obj, "x", MyStruct::properties());std::cout << "Field x has value: " << *x_value << std::endl;auto y_value = get_field_value<float>(obj, "y", MyStruct::properties());std::cout << "Field y has value: " << *y_value << std::endl;auto z_value = get_field_value<int>(obj, "z", MyStruct::properties()); // "z" 不存在std::cout << "Field z has value: " << z_value << std::endl;// 通过字符串调用成员函数 'print'auto print_ret = refl::invoke_member_func<int>(obj, "print");std::cout << "print member return: " << print_ret.value() << std::endl;return 0;
}

这个反射库用到了折叠表达式，因此需要支持C++17的编译器才能正常编译。
编译运行后，可以看到结构体的名称被正确的显示出来：
在这里插入图片描述

这个编译时反射库非常基础，只支持非静态数据成员，并且每个字段必须手动注册。在实际应用中，一个成熟的编译时反射库会更复杂，支持更多功能，如类型信息查询、继承关系处理等。但是，我们通过这个例子，可以更久深入地理解C++的编译时反射的实现原理和技术细节，非常有趣。
针对这个库进一步完善，可以参考文章：深入探讨C++的高级反射机制（2）：写个能用的反射库

扩展知识：关于C++的折叠表达式

我们前面提到，由于用到了折叠表达式，需要支持C++17的编译器才能正常编译。那么什么折叠表达式呢？
C++的折叠表达式（Fold Expression）是C++17标准引入的一种新特性，它允许对一个包含了所有参数的参数包进行一个二元操作的展开。折叠表达式可以简化有关变参模板函数的编写，例如上面我们需要对所有的变参执行某项操作时。

折叠表达式有两种形式：一元右折叠和一元左折叠。它们分别用 (... op pack) 和 (pack op ...) 表示，其中 op 是一个二元运算符，pack 是一个参数包。C++17也支持二元折叠表达式 (init op ... op pack) 和 (pack op ... op init)。

以下是一些折叠表达式的例子：

template<typename... Args>
auto sum(Args... args) {return (... + args); // 一元右折叠，将参数包中所有元素求和
}template<typename... Args>
auto logical_and(Args... args) {return (true && ... && args); // 二元左折叠，逻辑与操作
}template<typename... Args>
bool all_positive(Args... args) {return ((args > 0) && ...); // 一元右折叠，判断所有参数是否都大于0
}