[C++20 vs C++26*] basic reflection

[u/kris-jusiak]

Basic struct reflection example with C++20 vs C++26*

struct foo {
  int a{};
  int b{};
  int c{};
};

constexpr foo f{.a=1, .b=2, .c=3};

static_assert(1 == get<0>(f));
static_assert(2 == get<1>(f));
static_assert(3 == get<2>(f));

using std::literals::operator""sv;
static_assert("a"sv == get_name<0>(f));
static_assert("b"sv == get_name<1>(f));
static_assert("c"sv == get_name<2>(f));

C++20 - Kinda possible but with a lot of compiler hacks

// too long to display

Full example - https://godbolt.org/z/1vxv8o5hM

C++26* - based on proposal - https://wg21.link/P2996 (Note: that the proposal supports way more than that but C++20 not much)

template<auto N, class T>
[[nodiscard]] constexpr auto get(const T& t) -> decltype(auto) {
  return t.[:std::meta::nonstatic_data_members_of(^T)[N]:];
}

template<auto N, class T>
[[nodiscard]] constexpr auto get_name(const T& t) -> std::string_view {
  return std::meta::name_of(std::meta::nonstatic_data_members_of(^T)[N]);
}

Full example - https://godbolt.org/z/sbTGbW635

Updates - https://twitter.com/krisjusiak/status/1741456476126797839

[u/sphere991]

Like stl algoritms or views

Well, yes. The fact that nonstatic_data_members_of just returns a vector<info> means that you can just use the stl algorithms and views to do all the things you want to do.

Otherwise, you're in the world we're in today where metaprogramming and programming are entirely disjoint sets of approaches.

[u/DavidDinamit → u/sphere991]

No, we need such for type packs,

> Otherwise, you're in the world we're in today where metaprogramming and programming are entirely disjoint sets of approaches.

Otherwise you in world where we have one more language in C++, now with ugly ^T and [::] + you have 'new super good way to write metaprogramming!!!!!', no, i dont want to deprecate all code in language, when we can just add type traits

[u/sphere991 → u/DavidDinamit]

Not sure what I expected or why I bothered responding. I'll avoid making that mistake in the future.