C++ PFR (Plain Fundamental Reflection)：简化编译期反射的库

好的，各位观众，欢迎来到“C++ PFR：让你的代码像八卦一样透明”讲座！

今天咱们要聊聊 C++ 里的一个“神器”—— PFR，也就是 Plain Fundamental Reflection。啥是 PFR 呢？简单来说，它是一个库，能够让你在编译期像扒明星隐私一样，获取 C++ 结构体或类的成员信息，而不需要动用那些复杂的元编程技巧。

为什么要用 PFR？

在传统的 C++ 里，如果你想在运行时获取一个类的成员变量名称、类型，或者访问它们的值，通常需要用到一些比较重量级的反射机制。这些机制要么是编译器内置的，要么需要借助外部工具生成代码。但这些方法往往比较复杂，学习曲线陡峭，而且可能会影响编译速度。

PFR 的出现就是为了解决这个问题。它利用了一些 C++17/20 的新特性，比如结构化绑定、constexpr 等，让你可以用一种非常简洁、高效的方式来访问类的成员。

PFR 的核心思想

PFR 的核心思想就是把一个结构体或类看作是一个“元组”（tuple）。元组里的每个元素对应着类的一个成员变量。这样，我们就可以利用标准库里 std::tuple 的一些操作，比如 std::get、std::tuple_size 等，来访问类的成员。

PFR 的基本用法

首先，你需要包含 PFR 的头文件：

#include <boost/pfr.hpp> //或者 #include <boost/pfr/ops.hpp>

接下来，定义一个简单的结构体：

struct Person {
  std::string name;
  int age;
  double height;
};

然后，你就可以使用 PFR 来访问 Person 结构体的成员了：

Person p{"Alice", 30, 1.75};

// 获取成员数量
size_t num_fields = boost::pfr::tuple_size<Person>::value;
std::cout << "Number of fields: " << num_fields << std::endl; // 输出: 3

// 获取成员值
std::cout << "Name: " << boost::pfr::get<0>(p) << std::endl;   // 输出: Alice
std::cout << "Age: " << boost::pfr::get<1>(p) << std::endl;    // 输出: 30
std::cout << "Height: " << boost::pfr::get<2>(p) << std::endl; // 输出: 1.75

// 还可以使用迭代器来遍历成员
boost::pfr::for_each_field(p, [](const auto& field) {
  std::cout << field << std::endl;
});

是不是很简单？就像访问一个数组一样，你可以通过索引来访问类的成员。

PFR 的高级用法

除了基本的成员访问，PFR 还提供了一些更高级的功能，比如：

boost::pfr::structure_to_tuple: 将结构体转换为一个元组。
boost::pfr::get_name: 获取成员变量的名称（C++20 需要编译器支持）。
boost::pfr::equal / boost::pfr::not_equal: 比较两个结构体是否相等。
boost::pfr::io: 将结构体输出到流。

下面是一些例子：

#include <iostream>
#include <string>
#include <boost/pfr.hpp>
#include <boost/pfr/ops.hpp> // 包含 equal, not_equal, operator<< 等

struct Person {
  std::string name;
  int age;
  double height;
};

int main() {
  Person p1{"Alice", 30, 1.75};
  Person p2{"Bob", 25, 1.80};
  Person p3{"Alice", 30, 1.75};

  // 比较两个结构体是否相等
  if (boost::pfr::equal(p1, p2)) {
    std::cout << "p1 and p2 are equal" << std::endl;
  } else {
    std::cout << "p1 and p2 are not equal" << std::endl; // 输出
  }

  if (boost::pfr::equal(p1, p3)) {
    std::cout << "p1 and p3 are equal" << std::endl; // 输出
  } else {
    std::cout << "p1 and p3 are not equal" << std::endl;
  }

  // 将结构体输出到流
  std::cout << "Person p1: " << p1 << std::endl; // 输出: Person p1: {Alice, 30, 1.75}

#if __cplusplus >= 202002L // 需要 C++20 支持

  // 获取成员变量的名称
  std::cout << "Name of field 0: " << boost::pfr::get_name<0, Person>() << std::endl; // 输出: name
  std::cout << "Name of field 1: " << boost::pfr::get_name<1, Person>() << std::endl; // 输出: age
  std::cout << "Name of field 2: " << boost::pfr::get_name<2, Person>() << std::endl; // 输出: height

#endif

  return 0;
}

PFR 的优点

简单易用：PFR 的 API 非常简洁，容易上手。
编译期反射：PFR 的所有操作都在编译期完成，不会带来运行时的开销。
高效：PFR 使用了 C++17/20 的新特性，性能非常高。
无需修改结构体/类定义：PFR 不需要你修改现有的结构体或类定义。

PFR 的限制

只支持 Plain Old Data (POD) 类型：PFR 只能用于没有虚函数、没有自定义构造函数、析构函数和赋值运算符的类和结构体。如果类有这些东西，PFR就没法正常工作了。
需要 C++17/20 支持：PFR 需要 C++17 或 C++20 的编译器支持。
不能访问私有成员：PFR 只能访问公共成员变量。
依赖 Boost 库：虽然 PFR 是一个独立的库，但它依赖于 Boost 库。你需要安装 Boost 才能使用 PFR。不过， boost::pfr 的代码是 header-only 的，只需要把头文件包含进你的项目就可以编译了，不需要链接 boost 的库。

PFR 的应用场景

PFR 可以用于很多场景，比如：

序列化/反序列化：你可以使用 PFR 来自动生成序列化和反序列化的代码。
数据校验：你可以使用 PFR 来自动生成数据校验的代码。
ORM (Object-Relational Mapping)：你可以使用 PFR 来将对象映射到数据库表。
通用算法：你可以使用 PFR 来编写一些通用的算法，可以处理不同的数据类型。
测试：你可以使用 PFR 来比较两个对象的成员是否相等，方便进行单元测试。

代码示例：序列化

下面是一个使用 PFR 进行序列化的例子：

#include <iostream>
#include <fstream>
#include <string>
#include <boost/pfr.hpp>

struct Person {
  std::string name;
  int age;
  double height;
};

// 序列化函数
template <typename T>
void serialize(const T& obj, std::ostream& os) {
  boost::pfr::for_each_field(obj, [&os](const auto& field) {
    os << field << ",";
  });
  os << std::endl;
}

// 反序列化函数 (简化版，没有错误处理)
template <typename T>
void deserialize(T& obj, std::istream& is) {
  size_t index = 0;
  boost::pfr::for_each_field(obj, [&is, &index](auto& field) {
      std::string value;
      std::getline(is, value, ',');
      std::stringstream ss(value);
      ss >> field;
      ++index;
  });
}

int main() {
  Person p1{"Alice", 30, 1.75};

  // 序列化到文件
  std::ofstream ofs("person.txt");
  serialize(p1, ofs);
  ofs.close();

  // 从文件反序列化
  Person p2;
  std::ifstream ifs("person.txt");
  deserialize(p2, ifs);
  ifs.close();

  // 打印反序列化的结果
  std::cout << "Name: " << p2.name << std::endl;   // 输出: Alice
  std::cout << "Age: " << p2.age << std::endl;    // 输出: 30
  std::cout << "Height: " << p2.height << std::endl; // 输出: 1.75

  return 0;
}

在这个例子中，我们定义了 serialize 和 deserialize 两个函数，分别用于将 Person 对象序列化到文件和从文件反序列化。这两个函数都使用了 boost::pfr::for_each_field 来遍历 Person 结构体的成员。

代码示例：数据校验

下面是一个使用 PFR 进行数据校验的例子：

#include <iostream>
#include <string>
#include <boost/pfr.hpp>

struct Person {
  std::string name;
  int age;
  double height;
};

// 数据校验函数
template <typename T>
bool validate(const T& obj) {
  bool valid = true;
  boost::pfr::for_each_field(obj, [&valid](const auto& field) {
    // 这里可以根据不同的字段类型进行不同的校验
    if constexpr (std::is_same_v<decltype(field), std::string>) {
      if (field.empty()) {
        std::cout << "Name cannot be empty" << std::endl;
        valid = false;
      }
    } else if constexpr (std::is_same_v<decltype(field), int>) {
      if (field < 0 || field > 150) {
        std::cout << "Age is invalid" << std::endl;
        valid = false;
      }
    } else if constexpr (std::is_same_v<decltype(field), double>) {
      if (field < 0.0 || field > 3.0) {
        std::cout << "Height is invalid" << std::endl;
        valid = false;
      }
    }
  });
  return valid;
}

int main() {
  Person p1{"Alice", 30, 1.75};
  Person p2{"", 200, 4.0};

  if (validate(p1)) {
    std::cout << "Person p1 is valid" << std::endl; // 输出
  } else {
    std::cout << "Person p1 is invalid" << std::endl;
  }

  if (validate(p2)) {
    std::cout << "Person p2 is valid" << std::endl;
  } else {
    std::cout << "Person p2 is invalid" << std::endl; // 输出 "Name cannot be empty" 和 "Age is invalid" 和 "Height is invalid"
  }

  return 0;
}

在这个例子中，我们定义了一个 validate 函数，用于校验 Person 对象的成员变量。 validate 函数使用了 boost::pfr::for_each_field 来遍历 Person 结构体的成员，并根据不同的字段类型进行不同的校验。

PFR 与其他反射机制的比较

特性	PFR	传统反射 (如 Qt Meta Object System)
实现方式	编译期元编程	运行时类型信息 (RTTI) 或代码生成
性能	非常高，无运行时开销	相对较低，有运行时开销
易用性	简单易用	相对复杂
灵活性	有限，只能用于 POD 类型	更灵活，支持更多类型
依赖	Boost 库	编译器或框架支持
应用场景	序列化、数据校验等	GUI、插件系统等

总结

PFR 是一个非常实用的 C++ 库，它可以让你在编译期像访问元组一样访问结构体或类的成员。它简单易用、高效，可以用于很多场景。如果你需要对 POD 类型进行反射操作，PFR 是一个非常不错的选择。

希望今天的讲座能够帮助大家更好地理解和使用 PFR。谢谢大家！

发表回复 取消回复

发表回复取消回复