purecpp - a cool open source modern c++ community

yalantinglibs.reflection 的实现原理

编辑时间：2024-08-04 11:54:55 作者：qicosmos 0条评论

出自：purecpp.cn

地址： www.purecpp.cn

转载请注明出处！

“要有光！”

于是就有了光——

《最后的问题》——阿西莫夫

社区用户说：不要宏！

于是宏就没有了——

曾经我一度认为完整的编译期反射在C++26之前是离不开宏的，直到发现了那道光！

# C++17 基于structure binding的编译期反射

事实上不需要宏的编译期反射在C++17中已经用得很多了，比如struct_pack 的编译期反射就不需要宏，因为C++17 structure binding可以直接得到一个aggregate 类的成员的引用。

```cpp
struct person {
  int id;
  std::string name;
  int age;
};

int main() {
  person p{1, "tom", 20};
  auto &[id, name, age] = p;
  std::cout << name << "\n"; 
}
```
没有宏也没有侵入式，一切看起来都很完美，但是存在两个比较大的问题：

## 问题一
structure binding方式无法获取字段名称，这是一个主要问题，如果希望将对象序列化到json，xml时，需要字段名的时候就无法满足需求了。

## 问题二
除此之外还有另外一个问题，如果一个对象有构造函数或者私有成员时，那么它就不是一个aggregate类型了，无法再通过structure binding去反射内部的字段了。

基于structure binding的编译期反射无法解决这两个主要问题，导致其并不能在更广泛的场景下使用。

# yalantinglibs.reflection 反射库
yalantinglibs.reflection反射库直面并解决了这两个问题，提供了统一的编译期反射解决方案，无论对象是否是aggregate类型，无论对象是否存在私有字段都可以通过统一的api在编译期反射得到其元信息。

来看看yalantinglibs.reflection 如何反射一个aggregate 类型的：

```cpp
struct simple {
  int color;
  int id;
  std::string str;
  int age;
};

using namespace ylt::reflection;
int main() {
  simple p{.color = 2, .id = 10, .str = "hello reflection", .age = 6};

// 获取对象字段个数
  static_assert(members_count_v<simple> == 4);
  
  // 获取对象所有字段名
  constexpr auto arr = member_names<simple>; //std::array<std::string_view, N>
  
  // 根据字段索引获取字段值
  CHECK(std::get<3> == 6); //get age
  CHECK(std::get<2> == "hello reflection"); //get str

// 根据字段名获取字段值
  auto& age2 = get<"age"_ylts>(p);
  CHECK(age2 == 6);

// 遍历对象，得到字段值和字段名
  for_each(p, [](auto& field_value, auto field_name) {
    std::cout << field_value << ", " << field_name << "\n";
  });
}
```
yalantinglibs的编译期反射相比之前structure binding 方式的反射更进一步了，不仅仅是无宏非侵入式，还能得到字段名，这样就把第一个问题解决掉了，可以将其用在json和xml等需要字段名的场景下了。

yalantinglibs.reflection 是如何做到非侵入式拿到aggregate对象的字段名的呢？因为reflect-cpp这道光！

这个库的作者发现了一种新方法可以在C++20 高版本的编译器中非侵入式的拿到aggregate对象的字段名。能发现这种方法我只能说You're a genius！

这个方法说起来也不算复杂，分两步实现：

第一步：在编译期拿到对象字段值的指针；

第二步：在编译期通过第一步得到的指针解析出字段名；

看起来是不是很简单，接下来看看具体是如何实现的吧。

## 在编译期拿到对象字段值的指针
reflect-cpp 在实现这一步的时候做得比较复杂，yalantinglibs大幅简化了这一步的实现。
```cpp
template <class T, std::size_t n>
struct object_tuple_view_helper {
  static constexpr auto tuple_view(){}
};

template <class T>
struct object_tuple_view_helper<T, 0> {
  static constexpr auto tuple_view() { return std::tie(); }
};

template <class T>                                                                
struct object_tuple_view_helper<T, 4> {                                           
  static constexpr auto tuple_view() {                                            
    auto& [a, b, c, d] = get_fake_object<remove_cvref_t<T>>();                   
    auto ref_tup = std::tie(a, b, c, d);                                         
    auto get_ptrs = [](auto&... _refs) {                                          
      return std::make_tuple(&_refs...);                                          
    };                                                                            
    return std::apply(get_ptrs, ref_tup);                                         
  }
};
```

通过偏特化模板类object_tuple_view_helper，在tuple_view函数中，先通过structure binding 得到字段值的引用，然后将其转换为指针，并放到tuple中返回给用户。这里偏特化的关键在于n，它表示aggregate对象字段的个数，这个字段个数是可以在编译期获取的。为了避免针对不同字段个数的aggregate 类型写重复的偏特化的代码，可以通过一个脚本去生成这些代码。

```cpp
#define RFL_INTERNAL_OBJECT_IF_YOU_SEE_AN_ERROR_REFER_TO_DOCUMENTATION_ON_C_ARRAYS( \
    n, ...)                                                                         \
  template <class T>                                                                \
  struct object_tuple_view_helper<T, n> {                                           \
    static constexpr auto tuple_view() {                                            \
      auto& [__VA_ARGS__] = get_fake_object<remove_cvref_t<T>>();                   \
      auto ref_tup = std::tie(__VA_ARGS__);                                         \
      auto get_ptrs = [](auto&... _refs) {                                          \
        return std::make_tuple(&_refs...);                                          \
      };                                                                            \
      return std::apply(get_ptrs, ref_tup);                                         \
    }                                                                               \
  }

/*The following boilerplate code was generated using a Python script:
macro =
"RFL_INTERNAL_OBJECT_IF_YOU_SEE_AN_ERROR_REFER_TO_DOCUMENTATION_ON_C_ARRAYS"
with open("generated_code4.cpp", "w", encoding="utf-8") as codefile:
    codefile.write(
        "\n".join(
            [
                f"{macro}({i}, {', '.join([f'f{j}' for j in range(i)])});"
                for i in range(1, 256)
            ]
        )
    )
*/

RFL_INTERNAL_OBJECT_IF_YOU_SEE_AN_ERROR_REFER_TO_DOCUMENTATION_ON_C_ARRAYS(1,
                                                                           f0);
RFL_INTERNAL_OBJECT_IF_YOU_SEE_AN_ERROR_REFER_TO_DOCUMENTATION_ON_C_ARRAYS(2,
                                                                           f0,
                                                                           f1);
RFL_INTERNAL_OBJECT_IF_YOU_SEE_AN_ERROR_REFER_TO_DOCUMENTATION_ON_C_ARRAYS(3,
                                                                           f0,
                                                                           f1,
                                                                           f2);
RFL_INTERNAL_OBJECT_IF_YOU_SEE_AN_ERROR_REFER_TO_DOCUMENTATION_ON_C_ARRAYS(
    4, f0, f1, f2, f3);
RFL_INTERNAL_OBJECT_IF_YOU_SEE_AN_ERROR_REFER_TO_DOCUMENTATION_ON_C_ARRAYS(
    5, f0, f1, f2, f3, f4);
RFL_INTERNAL_OBJECT_IF_YOU_SEE_AN_ERROR_REFER_TO_DOCUMENTATION_ON_C_ARRAYS(
    6, f0, f1, f2, f3, f4, f5);
```

这些偏特化的代码生成之后，就可以通过简单的方法拿到aggregate 对象字段的指针。
```cpp
template <class T>
inline constexpr auto struct_to_tuple() {
  return object_tuple_view_helper<T, members_count_v<T>>::tuple_view();
}
```

调用struct_to_tuple就能在编译期拿到T所有字段的指针了，其中编译期获取T的字段个数的方法members_count_v就是来自于struct_pack中的方法，之前在介绍struct_pack 的文章里已经详细讲过就不再赘述了。

## 根据字段指针获取字段名
有了编译期得到的字段指针之后就很容易获取其字段名了：
```cpp
template <auto ptr>
inline constexpr std::string_view get_member_name() {
#if defined(_MSC_VER)
  constexpr std::string_view func_name = __FUNCSIG__;
#else
  constexpr std::string_view func_name = __PRETTY_FUNCTION__;
#endif

#if defined(__clang__)
  auto split = func_name.substr(0, func_name.size() - 2);
  return split.substr(split.find_last_of(":.") + 1);
#elif defined(__GNUC__)
  auto split = func_name.substr(0, func_name.rfind(")}"));
  return split.substr(split.find_last_of(":") + 1);
#elif defined(_MSC_VER)
  auto split = func_name.substr(0, func_name.rfind("}>"));
  return split.substr(split.rfind("->") + 2);
#else
  static_assert(false,
                "You are using an unsupported compiler. Please use GCC, Clang "
                "or MSVC or switch to the rfl::Field-syntax.");
#endif
}
```
`template <auto ptr>` 是C++17的特性，可以通过auto来声明一个非类型模板参数，这样写也是为了避免写具体类型简化用书写。

有了这个编译期的ptr之后，剩下的就是根据编译产生的符号去截取需要的部分字符串了，注意每个平台生成的符号有差异，需要通过宏来区分各个平台的截取方式。

为什么可以通过指针能获取字段名？C++17或以下的编译器是不是也可以通过这个方法来获取呢？

第一个问题的答案是: reflect-cpp作者发现的这个方法，很hack，但是it works！

第二个问题的答案是: no，这种方法只在支持C++20的gcc11，clang13，msvc2022 以上编译器中才有效！

所以这种非侵入式获取字段名的方法也是有约束的，不适合低版本的编译器。

完整的获取字段列表的实现:
```cpp
template <class T>
struct Wrapper {
  using Type = T;
  T v;
};

template <class T>
Wrapper(T) -> Wrapper<T>;

// This workaround is necessary for clang.
template <class T>
inline constexpr auto wrap(const T& arg) noexcept {
  return Wrapper{arg};
}

template <typename T>
inline constexpr std::array<std::string_view, members_count_v<T>>
get_member_names() {
  constexpr auto tp = struct_to_tuple<T>();

std::array<std::string_view, Count> arr;
    [&]<size_t... Is>(std::index_sequence<Is...>) mutable {
    ((arr[Is] = get_member_name<wrap(std::get<Is>(tp))>()), ...);
  }
  (std::make_index_sequence<Count>{});

return arr;
}
```

至此，两步完成，可以通过get_member_names函数非侵入式的拿到aggregate 对象字段的名称列表了。

# 如何处理非aggregate类型？
在高版本的编译器中无宏非侵入式得到aggregate 对象字段的名称列表固然很好，但是非aggregate类型要如何处理呢？如果编译器版本不够，只有C++17又该怎么办？

yalantinglibs.reflection 的scope远不止你想象的那么大，它希望能统一整个编译期反射的内容，无论对象是aggregate 还是非aggregate，无论对象是否含有私有字段都提供统一的反射接口！

比如像这样一个对象：

```cpp
class private_struct {
  int a;
  int b;

public:
  private_struct(int x, int y) : a(x), b(y) {}
};

private_struct st(2, 4);
  ylt::reflection::refl_visit_members(st, [](auto&... args) {
    ((std::cout << args << " "), ...);
    std::cout << "\n";
  });
```
private_struct是一个含私有字段的非aggregate类型，但是ylt::reflection也能将其反射出来。但是这里还漏掉了一个宏，是的，还是需要宏，对于非aggregate类型在编译期反射进入到标准库之前仍然需要的。

```cpp
class private_struct {
  int a;
  int b;

public:
  private_struct(int x, int y) : a(x), b(y) {}
};
YLT_REFL_PRIVATE(private_struct, a, b);
```

对于没有private字段的非aggregate类型来说，也适用于C++17，可以这样定义宏:
```cpp
struct dummy_t {
  int id;
  std::string name;
  int age;
  YLT_REFL(dummy_t, id, name, age);
};

struct dummy_t2 {
  int id;
  std::string name;
  int age;
};
YLT_REFL(dummy_t2, id, name, age);
```

# 总结
高版本的编译器中可以完全不使用宏，低版本或者非aggregate类型通过宏来实现编译器反射，无论是aggregate还是非aggregate都是使用同一套反射接口，这样可以覆盖所有的需要使用编译期反射的场景，这就是yalantinglibs.reflection提供的能力！

后面struct_pack, struct_pb, struct_json，struct_xml，struct_yaml都会使用yalantinglibs.reflection提供的统一的编译期反射接口去实现序列化和反序列化。

最后附上一首小诗：

**写代码有感**

**键盘声里度晨昏，代码行中世外人。**

**奥秘难猜需顿悟，匠心独具耐研寻。**

来说两句吧