C++ 编译期反射：使用模板元编程生成类型信息与成员访问器 - 智猿学院-前后端，数据库，人工智能，云计算等领域前沿技术讲座

哈喽，各位好！今天咱们来聊点儿 C++ 里面“骚操作”的东西——编译期反射。别害怕，听起来玄乎，其实就是利用 C++ 的模板元编程能力，在编译的时候“扒”出类型的信息，还能生成访问成员变量的“小帮手”。

一、啥是反射？凭啥要编译期？

首先，得搞清楚反射是个啥玩意儿。简单来说，反射就是程序在运行时检查自身结构的能力，比如知道自己有哪些类，类里有哪些成员变量、成员函数等等。很多语言都有运行时反射，比如 Java、C#。

但 C++ 嘛，比较“硬核”，默认没有运行时反射。原因嘛，一方面是为了性能，运行时反射会带来额外的开销；另一方面，C++ 的设计哲学是尽量把能放到编译期做的事情，就放到编译期做，这样运行时效率更高。

所以，咱们今天要聊的编译期反射，就是利用 C++ 的模板元编程，在编译的时候“模拟”反射的功能。

为啥要用编译期反射？

序列化/反序列化： 自动生成代码，把对象转换成字符串，或者从字符串还原成对象。
ORM（对象关系映射）： 自动把数据库里的数据映射成 C++ 对象。
GUI 框架： 自动绑定 UI 控件和对象的属性。
自动化测试： 自动生成测试用例。
代码生成： 根据类型信息生成其他的代码，比如生成访问器。

二、模板元编程：反射的“发动机”

要实现编译期反射，离不开 C++ 的模板元编程。简单来说，模板元编程就是利用模板，在编译的时候进行计算。它就像一个“编译期虚拟机”，可以在编译的时候执行一些逻辑。

模板元编程的核心思想是：

模板是“函数”： 模板可以接受类型作为参数，返回一个新的类型。
特化是“分支”： 可以通过特化模板，实现不同的逻辑分支。
递归是“循环”： 可以通过递归调用模板，实现循环的效果。

听起来有点儿抽象？没关系，咱们结合代码来看。

三、初窥门径：获取类型名称

最简单的编译期反射，就是获取类型的名称。这可以通过一个模板类来实现：

#include <iostream>
#include <string>
#include <typeinfo>

template <typename T>
struct TypeName {
    static constexpr const char* name = typeid(T).name();
};

int main() {
    std::cout << TypeName<int>::name << std::endl;   // 输出 "i" (取决于编译器)
    std::cout << TypeName<double>::name << std::endl; // 输出 "d" (取决于编译器)
    return 0;
}

这个代码非常简单，使用了 typeid 运算符来获取类型的名称。但是要注意，typeid 返回的名称是编译器相关的，不同的编译器可能会返回不同的结果。而且，这个名称通常是“经过编码”的，可读性比较差。例如，在 GCC 中，int 可能会被编码成 i，std::string 可能会被编码成 NSt7__cxx1112basic_stringIcSt11char_traitsIcESaIcEEE。

为了获得更友好的类型名称，可以使用一些技巧，比如使用预处理宏，或者使用第三方库。但这些方法都比较复杂，而且可移植性比较差。所以，获取类型名称只是编译期反射的一个“开胃菜”。

四、更进一步：枚举类的成员变量

现在，咱们来点儿更刺激的：枚举类的成员变量。这需要用到一些更高级的模板元编程技巧。

首先，我们需要一个“类型列表”，用于存储类的成员变量的类型。这可以通过一个模板类来实现：

template <typename... Types>
struct TypeList {};

这个 TypeList 模板类可以接受任意数量的类型作为参数，并将它们存储在一个列表中。

接下来，我们需要一个宏，用于定义类的成员变量，并将它们的类型添加到 TypeList 中。

#define FIELD(type, name) type name; using name##_type = type;

这个宏接受两个参数：成员变量的类型和名称。它定义了一个成员变量，并定义了一个类型别名，用于获取成员变量的类型。

最后，我们需要一个模板类，用于获取类的 TypeList。

template <typename T>
struct ClassInfo;

#define CLASS(name, ...) 
struct name { 
  template <typename U> 
  struct ClassInfoHelper {}; 
  template <> 
  struct ClassInfoHelper<name> { 
    using type_list = TypeList<__VA_ARGS__>; 
  }; 
  using ClassInfo = typename ClassInfoHelper<name>::type_list; 
};

这个宏定义了一个类，以及一个 ClassInfo 类型别名，用于获取类的 TypeList。ClassInfo 使用 SFINAE (Substitution Failure Is Not An Error) 来实现，如果 name 不是当前类，那么 ClassInfoHelper<name> 将会编译失败，但是不会导致编译错误。

现在，咱们可以定义一个类，并使用这些宏来枚举它的成员变量：

CLASS(MyClass, int, double, std::string) {
    FIELD(int, age)
    FIELD(double, salary)
    FIELD(std::string, name)
};

int main() {
    using MyClassInfo = MyClass::ClassInfo;
    // MyClassInfo 是 TypeList<int, double, std::string>
    return 0;
}

这个代码定义了一个 MyClass 类，它有三个成员变量：age、salary 和 name。MyClass::ClassInfo 是一个 TypeList，它包含了这三个成员变量的类型。

五、终极挑战：生成成员访问器

有了类的成员变量类型列表，就可以生成访问这些成员变量的“小帮手”了。这可以通过一个模板函数来实现：

template <typename ClassType, typename FieldType, FieldType ClassType::* FieldPtr>
struct MemberAccessor {
    ClassType& obj;

    MemberAccessor(ClassType& obj) : obj(obj) {}

    FieldType get() const {
        return obj.*FieldPtr;
    }

    void set(const FieldType& value) {
        obj.*FieldPtr = value;
    }
};

template <typename ClassType, typename FieldType, FieldType ClassType::* FieldPtr>
MemberAccessor<ClassType, FieldType, FieldPtr> make_member_accessor(ClassType& obj) {
    return MemberAccessor<ClassType, FieldType, FieldPtr>(obj);
}

这个 MemberAccessor 模板类接受三个参数：类的类型、成员变量的类型，以及指向成员变量的指针。它提供 get 和 set 方法，用于访问成员变量。

现在，咱们可以定义一个宏，用于生成 MemberAccessor。

#define MAKE_ACCESSOR(class_type, field_name) 
    auto field_name##_accessor = make_member_accessor<class_type, decltype(std::declval<class_type>().field_name), &class_type::field_name>(obj);

这个宏接受两个参数：类的类型和成员变量的名称。它生成一个 MemberAccessor 对象，用于访问成员变量。

现在，咱们可以定义一个类，并使用这些宏来生成成员访问器：

struct MyClass {
    int age;
    double salary;
    std::string name;
};

int main() {
    MyClass obj;
    obj.age = 30;
    obj.salary = 10000.0;
    obj.name = "Alice";

    MAKE_ACCESSOR(MyClass, age);
    MAKE_ACCESSOR(MyClass, salary);
    MAKE_ACCESSOR(MyClass, name);

    std::cout << "Age: " << age_accessor.get() << std::endl;
    age_accessor.set(31);
    std::cout << "New Age: " << age_accessor.get() << std::endl;
    return 0;
}

这个代码定义了一个 MyClass 类，它有三个成员变量：age、salary 和 name。它使用 MAKE_ACCESSOR 宏生成了三个 MemberAccessor 对象，用于访问这三个成员变量。

六、代码汇总与改进方向

下面是代码的汇总版本，包含一些改进，例如利用std::tuple存储类型列表，使用std::index_sequence来迭代类型列表：

#include <iostream>
#include <string>
#include <tuple>
#include <utility>

// 定义一个宏来声明字段，并存储字段类型
#define FIELD(type, name) type name; using name##_type = type;

// 定义一个宏来自动生成类的类型信息
#define CLASS(name, ...) 
struct name { 
private: 
    template <typename... Args> 
    using TypeList = std::tuple<Args...>; 
    using FieldTypes = TypeList<__VA_ARGS__>; 
public: 
    template <size_t I> 
    using FieldType = std::tuple_element_t<I, FieldTypes>; 
    static constexpr size_t FieldCount = std::tuple_size<FieldTypes>::value; 
};

// MemberAccessor 模板类，用于访问成员变量
template <typename ClassType, typename FieldType, FieldType ClassType::* FieldPtr>
struct MemberAccessor {
    ClassType& obj;

    MemberAccessor(ClassType& obj) : obj(obj) {}

    FieldType get() const {
        return obj.*FieldPtr;
    }

    void set(const FieldType& value) {
        obj.*FieldPtr = value;
    }
};

//辅助函数，创建MemberAccessor
template <typename ClassType, typename FieldType, FieldType ClassType::* FieldPtr>
MemberAccessor<ClassType, FieldType, FieldPtr> make_member_accessor(ClassType& obj) {
    return MemberAccessor<ClassType, FieldType, FieldPtr>(obj);
}

// 宏，简化 MemberAccessor 的创建
#define MAKE_ACCESSOR(class_type, field_name) 
    auto field_name##_accessor = make_member_accessor<class_type, decltype(std::declval<class_type>().field_name), &class_type::field_name>(obj);

//示例类
CLASS(MyClass, int, double, std::string) {
public:
    FIELD(int, age)
    FIELD(double, salary)
    FIELD(std::string, name)
};

int main() {
    MyClass obj;
    obj.age = 30;
    obj.salary = 10000.0;
    obj.name = "Alice";

    MAKE_ACCESSOR(MyClass, age);
    MAKE_ACCESSOR(MyClass, salary);
    MAKE_ACCESSOR(MyClass, name);

    std::cout << "Age: " << age_accessor.get() << std::endl;
    age_accessor.set(31);
    std::cout << "New Age: " << age_accessor.get() << std::endl;
    std::cout << "Salary: " << salary_accessor.get() << std::endl;
    std::cout << "Name: " << name_accessor.get() << std::endl;

    //输出类型信息
    std::cout << "Field Count: " << MyClass::FieldCount << std::endl;
    //std::cout << "Field 0 Type: " << typeid(MyClass::FieldType<0>).name() << std::endl; //需要更复杂的方式获取友好的类型名称
    return 0;
}

这个代码比之前的代码更加完整，它定义了 TypeList、FIELD、CLASS、MemberAccessor 和 MAKE_ACCESSOR 宏，用于实现编译期反射。

改进方向：

更友好的类型名称： 使用更高级的模板元编程技巧，或者使用第三方库，来获取更友好的类型名称。
更灵活的成员变量枚举： 可以使用一些技巧，比如使用 std::enable_if，来过滤掉不需要的成员变量。
自动生成序列化/反序列化代码： 可以根据类的成员变量类型列表，自动生成序列化/反序列化代码。
支持继承： 让反射机制支持类的继承关系。这会更复杂，需要处理基类的成员。

七、总结：编译期反射的“正确姿势”

编译期反射是一个非常强大的工具，它可以让你在编译的时候“扒”出类型的信息，并生成一些非常有用的代码。

但是，编译期反射也有一些缺点：

代码复杂： 模板元编程的代码通常比较复杂，难以理解和维护。
编译时间长： 模板元编程会在编译的时候进行大量的计算，这会增加编译时间。
可移植性差： 不同的编译器对模板元编程的支持程度不同，这会导致代码的可移植性比较差。

所以，在使用编译期反射的时候，需要权衡它的优点和缺点，选择最适合自己的方案。

总而言之，编译期反射是 C++ 中一个非常有趣和强大的特性，它为我们打开了一扇通往更高级编程技术的大门。虽然学习曲线比较陡峭，但掌握它绝对能让你在 C++ 的世界里更上一层楼！希望今天的分享能对大家有所帮助。

最后的最后，别忘了，模板元编程的“坑”很多，调试起来也很痛苦。所以，在实际项目中，一定要谨慎使用，避免过度设计，否则可能会适得其反。祝大家编程愉快！

发表回复 取消回复

发表回复取消回复