【C++编程】C++ 静态反射与序列化

vscode安装插件

#include <algorithm>
#include <iostream>
#include <string_view>
#include <tuple>
#include <type_traits>

namespace reflection {

template <class List, class T>
struct Append;
template <class... Ts, class T>
struct Append<std::tuple<Ts...>, T> {
  using type = std::tuple<Ts..., T>;
};

template <int N = 64>
struct Rank : Rank<N - 1> {};
template <>
struct Rank<0> {};

[[maybe_unused]] static std::tuple<> CollectField(Rank<0>);

struct Helper {
  template <class T>
  static auto getFieldInfo() -> decltype(T::CollectField(Rank<>{}));

  template <class T>
  using FieldInfoList = decltype(getFieldInfo<T>());

  template <class T>
  static constexpr size_t Size = std::tuple_size_v<FieldInfoList<T>>;

  template <class T, size_t I>
  using FieldInfo = std::tuple_element_t<I, FieldInfoList<T>>;
};

#define REFL_NOW decltype(CollectField(::reflection::Rank<>{}))
#define REFL_ADD(info)                                                      \
  static ::reflection::Append<REFL_NOW, decltype(info)>::type CollectField( \
      ::reflection::Rank<std::tuple_size_v<REFL_NOW> + 1>)

}  // namespace reflection

namespace thief {

template <class T>
struct Bridge {
#if defined(__GNUC__) && !defined(__clang__)
// Silence unnecessary warning
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wnon-template-friend"
#endif
  friend auto ADL(Bridge<T>);
#if defined(__GNUC__) && !defined(__clang__)
#pragma GCC diagnostic pop
#endif
};

template <class T, class U>
struct StealType {
  friend auto ADL(Bridge<T>) { return std::type_identity<U>{}; }
};

template <class Tag, class Store>
using steal = decltype(StealType<Tag, Store>{});

template <class Tag>
using retrieve = typename decltype(ADL(Bridge<Tag>{}))::type;

}  // namespace thief

template <size_t N>
struct NameWrapper {
  constexpr NameWrapper(const char (&str)[N]) { std::copy_n(str, N, string); }
  constexpr operator std::string_view() const { return {string, N - 1}; }
  char string[N];
};

template <NameWrapper Name, auto Getter>
struct FieldInfo {
  static constexpr std::string_view name = Name;
  static constexpr auto getter = Getter;
};

#define ADD_FIELD(NAME, DEFAULT)                                       \
 protected:                                                            \
  friend struct ::reflection::Helper;                                  \
  struct T##NAME : std::type_identity<decltype(DEFAULT)> {};           \
                                                                       \
 public:                                                               \
  T##NAME::type NAME = DEFAULT;                                        \
                                                                       \
 private:                                                              \
  constexpr auto T##NAME()                                             \
      ->::thief::steal<struct T##NAME, std::decay_t<decltype(*this)>>; \
  REFL_ADD((FieldInfo<#NAME, &thief::retrieve<struct T##NAME>::NAME>{}))

struct A {
  ADD_FIELD(a, int{});
  ADD_FIELD(b, short{});
  ADD_FIELD(c, std::string{});
};

static_assert(reflection::Helper::Size<A> == 3);
static_assert(reflection::Helper::FieldInfo<A, 0>::name == "a");
static_assert(reflection::Helper::FieldInfo<A, 1>::name == "b");
static_assert(reflection::Helper::FieldInfo<A, 2>::name == "c");

int main() {
  A a;
  a.a = 10;
  a.b = 20;
  a.c = "hello";

  std::apply(
      [&](auto&&... type) {
        ((std::cout << "name: " << type.name << ", value: " << a.*type.getter
                    << std::endl),
         ...);
      },
      ::reflection::Helper::FieldInfoList<A>{});
  return 0;
}

/*
 * name: a, value: 10
 * name: b, value: 20
 * name: c, value: hello
 */

 

 

参考资料

1. C++ 静态反射与序列化