反射是一种编程语言能力，允许程序在运行时查询和操纵对象的类型信息。它广泛应用于对象序列化、远程过程调用、测试框架、和依赖注入等场景。
由于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::forward

namespace 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
}

在第一个例子中，(... + args) 是一种右折叠表达式。如果传给 sum 函数的参数是 (1, 2, 3)，折叠表达式的展开将是 1 + (2 + 3)。

在第二个例子中，true && ... && args 是一种左折叠表达式。如果传的参数是 (a, b, c)，那么展开将是 true && a && b && c。

第三个例子是一种右折叠表达式，它检查所有参数是否都大于0。如果传的参数是 (1, 2, 3)，那么展开将是 1 > 0 && 2 > 0 && 3 > 0。

折叠表达式极大简化了变参模板代码的编写，使得对参数包的操作更加直接和清晰。在C++17之前，要对参数包中的所有元素进行操作通常涉及到递归模板实例化或使用初始化列表的技巧来实现，这相对来说更加复杂且代码可读性较差。

结语

如果你耐心的读到这里，相信你对C++的编译时反射的原理和实现都有了更深入的认识，以后再做C++反射相关的事情，也会更加游刃有余了。