2402C++,偷窥C++未来的反射

原文

在此体验.
只需要包含#include .

#include 
int main() {
    constexpr auto r = ^int;
    typename[:r:] x = 42;
    // ==: int x = 42;
    typename[:^char:] c = '*';
    // ==: char c = '*';
}

选择成员

这是一个操作成员的小示例:

struct S { unsigned i:2, j:6; };
consteval auto member_number(int n) {
 if (n == 0) return ^S::i;
 else if (n == 1) return ^S::j;
}
int main() {
 S s{0, 0};
 s.[:member_number(1):] = 42;
 //等同于:`s.j=42`;
 s.[:member_number(5):] = 0;
 //错误`(member_number(5)`不是常量).
}

通过提升(reflection)operator先返回meta::info反射类型,再通过splicing重新得到成员类型,从而访问成员.

类型列表转类型大小列表:

constexpr std::array types = {^int, ^float, ^double};
 //这里需要`consteval`,因为尚未实现`consteval`传播`(P2564)`
 
constexpr std::array sizes = []() consteval {
 std::array<std::size_t, types.size()> r;
 std::transform(types.begin(), types.end(), r.begin(), std::meta::size_of);
 return r;
}();
static_assert(sizes[0] == sizeof(int));
static_assert(sizes[1] == sizeof(float));
static_assert(sizes[2] == sizeof(double));

该示例同样很简单,不多讲,最终大小的内容就相当于:

std::array<std::size_t, 3> sizes = {sizeof(int), sizeof(float), sizeof(double)};

造整序

通过反射来简化实现make_integer_sequence:

template<typename T>
consteval std::meta::info make_integer_seq_refl(T N) {
 std::vector args{^T};
 for (T k = 0; k < N; ++k) {
 args.push_back(std::meta::reflect_value(k));
 }
 return substitute(^std::integer_sequence, args);
}
template<typename T, T N>
 using make_integer_sequence = [:make_integer_seq_refl<T>(N):];
static_assert(std::same_as<
 make_integer_sequence<int, 10>,
 std::make_integer_sequence<int, 10>
 >);

该实现逻辑也比较清晰,主要涉及两个reflect_value和substitude元函数.
其中,reflect_value的声明为:

namespace std::meta {
 template<typename T>
 consteval auto reflect_value(T const&)->info;
 template<typename R>
 consteval auto reflect_values(R const&)->std::span<info>;
}

这两个元函数来把Constantvalue(s)提升为(meta::info)反射类型表示,如:

constexpr std::vector<int> v{ 1, 2, 3 };
constexpr std::span<std::meta::info> rv = reflect_values(v);

随后,便可把该提升序列重新Splicing出来,如按模板参数使用:

std::integer_sequence<int, ...[:rv:]...> is123;
//与std::integer_sequence相同

以上仅是示例,EDGReflection尚不支持reflect_values,只支持reflect_value.

因此,

args.push_back(std::meta::reflect_value(k));

的意思,就是生成一个常数序列,再通过生成的序列创建一个std::integer_sequence,需要用到如下标准声明的substitute元函数:

namespace std::meta {
 consteval auto substitute(info templ, std::span<info> args)
 ->info { ... };
}

功能是根据已有类型,参数,生成新的类型.一例:

using namespace std::meta;
template<typename ... Ts> struct X {};
template<> struct X<int, int> {};
constexpr info type = ^X<int, int, float>;
constexpr info templ = template_of(type);
constexpr span<info> args = template_arguments_of(type);
constexpr info new_type = substitute(templ, args.subspan(0, 2));
 typename[:new_type:] xii; //`X`类型来选择`特化`.不能实例化`显式/部分特化`取代的`主模板定义`. 

根据X生成了新的X类型.
但是,EDG目前有些局限,它使用std::vector来代替std::span,因此

substitute(^std::integer_sequence, args);

中才使用std::vector参数.

用反射来取类布局信息:

struct member_descriptor
{
 std::size_t offset;
 std::size_t size;
 bool operator==(member_descriptor const&) const = default;
};
//返回`std::array`
template <typename S>
consteval auto get_layout() {
 constexpr size_t N = []() consteval {
 return nonstatic_data_members_of(^S).size();
 }();
 std::array<member_descriptor, N> layout;
 [: expand(nonstatic_data_members_of(^S)) :] >> [&, i=0]<auto e>() mutable {
 layout[i] = {.offset=offset_of(e), .size=size_of(e)};
 ++i;
 };
 return layout;
}
struct X
{
 char a;
 int b;
 double c;
};
constexpr auto Xd = get_layout<X>();
static_assert(Xd.size() == 3);
static_assert(Xd[0] == member_descriptor{.offset=0, .size=1});
static_assert(Xd[1] == member_descriptor{.offset=4, .size=4});
static_assert(Xd[2] == member_descriptor{.offset=8, .size=8});

get_layout()是主要逻辑点,来取类型的非静态数据成员信息,在member_descriptor里面保存信息.

因为EDG目前不支持扩展语句,所以增加了一些实现的复杂度.如果使用扩展语句,核心语句实现可这样:

std::array<member_descriptor, N> layout;
int i = 0;
template for (constexpr auto e : std::meta::nonstatic_data_members_of(^S)) {
 layout[i] = {.offset=offset_of(e), .size=size_of(e)};
 ++i;
}

expand()是EDG对扩展语句的临时平替,实现为:

namespace __impl {
 template<auto... vals>
 struct replicator_type {
 template<typename F>
 constexpr void operator>>(F body) const {
 (body.template operator()<vals>(), ...);
 }
 };
 template<auto... vals>
 replicator_type<vals...> replicator = {};
}
template<typename R>
consteval auto expand(R range) {
 std::vector<std::meta::info> args;
 for (auto r : range) {
 args.push_back(reflect_value(r));
 }
 return substitute(^__impl::replicator, args);
}

示例中其他使用的元函数皆这样,逻辑清晰,不必多讲.

枚举到串

最经典的示例,相当于反射界的你好,世界.
最经典的当属标准版本:

template <typename E>
 requires std::is_enum_v<E>
constexpr std::string enum_to_string(E value) {
 template for (constexpr auto e : std::meta::members_of(^E)) {
 if (value == [:e:]) {
 return std::string(std::meta::name_of(e));
 }
 }
 return "";
}
enum Color { red, green, blue };
static_assert(enum_to_string(Color::red) == "red");
static_assert(enum_to_string(Color(42)) == "");

及反操作版本:

template <typename E>
 requires std::is_enum_v<E>
constexpr std::optional<E> string_to_enum(std::string_view name) {
 template for (constexpr auto e : std::meta::members_of(^E)) {
 if (name == std::meta::name_of(e)) {
 return [:e:];
 }
 }
 return std::nullopt;
}

但是EDG不支持扩展语句,所以使用expand()代替:

template<typename E>
 requires std::is_enum_v<E>
constexpr std::string enum_to_string(E value) {
 std::string result = "";
 [:expand(std::meta::enumerators_of(^E)):] >>
 [&]<auto e>{
 if (value == [:e:]) {
 result = std::meta::name_of(e);
 }
 };
 return result;
}
enum Color { red, green, blue };
static_assert(enum_to_string(Color::red) == "red");
static_assert(enum_to_string(Color(42)) == "");

该实现的复杂度为O(N),他们提供了另一个利用Ranges算法只需要O(log(N))复杂度的实现:

template <typename E>
 requires std::is_enum_v<E>
constexpr std::string enum_to_string(E value) {
 constexpr auto enumerators =
 std::meta::members_of(^E)
 | std::views::transform([](std::meta::info e){
 return std::pair<E, std::string>(std::meta::value_of<E>(e), std::meta::name_of(e));
 })
 | std::ranges::to<std::map>();
 auto it = enumerators.find(value);
 if (it != enumerators.end()) {
 return it->second;
 } else {
 return "";
 }
}

这样借助std::map来实现.

实现元组

与传统递归继承实现相比,更简单的Tuple实现法:

namespace std::meta {
 consteval auto make_nsdm_description(info type, nsdm_options options = {}) {
 return nsdm_description(type, options);
 }
}
template<typename... Ts> struct Tuple {
 struct storage;
 static_assert(is_type(define_class(^storage, {make_nsdm_description(^Ts)...})));
 storage data;
 Tuple(): data{} {}
 Tuple(Ts const& ...vs): data{ vs... } {}
};
template<typename... Ts>
 struct std::tuple_size<Tuple<Ts...>>: public integral_constant<size_t, sizeof...(Ts)> {};
template<std::size_t I, typename... Ts>
struct std::tuple_element<I, Tuple<Ts...>> {
 static constexpr std::array types = {^Ts...};
 using type = [: types[I] :];
};
consteval std::meta::info get_nth_nsdm(std::meta::info r, std::size_t n) {
 return nonstatic_data_members_of(r)[n];
}
template<std::size_t I, typename... Ts>
 constexpr auto get(Tuple<Ts...> &t) noexcept -> std::tuple_element_t<I, Tuple<Ts...>>& {
 return t.data.[:get_nth_nsdm(^decltype(t.data), I):];
 }
template<std::size_t I, typename... Ts>
 constexpr auto get(Tuple<Ts...> const&t) noexcept -> std::tuple_element_t<I, Tuple<Ts...>> const& {
 return t.data.[:get_nth_nsdm(^decltype(t.data), I):];
 }
template<std::size_t I, typename... Ts>
 constexpr auto get(Tuple<Ts...> &&t) noexcept -> std::tuple_element_t<I, Tuple<Ts...>> && {
 return std::move(t).data.[:get_nth_nsdm(^decltype(t.data), I):];
 }
int main() {
 auto [x, y, z] = Tuple{1, 'c', 3.14};
 assert(x == 1);
 assert(y == 'c');
 assert(z == 3.14);
}

这样实现的关键在于生成代码,而EDG当前并不支持注入源码,所以提供了丐版的std::meta::nsdm_description和std::meta::define_class替代元函数,来允许合成简单的struct/union类型.声明为:

namespace std::meta {
 struct nsdm_options_t {
 optional<string_view> name;
 optional<int> alignment;
 optional<int> width;
 };
 consteval auto nsdm_description(info type, nsdm_options options = {}) -> info;
 consteval auto define_class(info class_type, span<info const>) -> info;
}

nsdm_description返回给定类型非静态数据成员的反射描述信息,nsdm_options_t指定数据成员的比如名,对齐和宽度等额外信息,
而define_class接受一个不完整的class/struct/union和非静态数据成员的反射元信息序列(由nsdm_description的返回值构成),把这些非静态数据成员注入到生成类型里面.

这就是注入源码的基本能力,弱化版的实现.
如:

template<typename T> struct S;
constexpr auto U = define_class(^S<int>, {
 nsdm_description(^int, {.name="i", .align=64}),
 nsdm_description(^int, {.name="j", .align=64}),
});
// S ==等价于.
// template<> struct S {
//   alignas(64) int i;
//   alignas(64) int j;
// };

为S自动生成的非静态数据成员,如果不指定nsdm_options_t,则生成的数据成员名默认为_0,_1,_2....
回到Tuple的实现,传统方法一个是递归继承,一个是递归复合,实现后者时有许多问题,因此一般利用前者实现.

而利用反射的生成代码能力,可直接合成一个storage内部类,把所有Tuple元素全部注入到该内部类当中,便可轻易地生成一个Tuple类.

借助反射,很容易实现std::tuple_element:

template<std::size_t I, typename... Ts>
struct std::tuple_element<I, Tuple<Ts...>> {
 static constexpr std::array types = {^Ts...};
 using type = [: types[I] :];
};

std::get的实现同样简单:

consteval std::meta::info get_nth_nsdm(std::meta::info r, std::size_t n) {
 return nonstatic_data_members_of(r)[n];
}
template<std::size_t I, typename... Ts>
 constexpr auto get(Tuple<Ts...> &t) noexcept -> std::tuple_element_t<I, Tuple<Ts...>>& {
 return t.data.[:get_nth_nsdm(^decltype(t.data), I):];
 }

通过反射,可直接操作类型元信息,不再需要额外的奇技淫巧去递归取这些信息.

构到构数组

这也是一个生成代码的示例:

namespace std::meta {
 consteval auto make_nsdm_description(info type, nsdm_options options = {}) {
 return nsdm_description(type, options);
 }
}

template <typename T, std::size_t N>
struct struct_of_arrays_impl;
consteval auto make_struct_of_arrays(std::meta::info type,
 std::meta::info N) -> std::meta::info {
 std::vector<std::meta::info> old_members = nonstatic_data_members_of(type);
 std::vector<std::meta::nsdm_description> new_members = {};
 for (std::meta::info member : old_members) {
 auto array_type = substitute(^std::array, {type_of(member), N });
 auto mem_descr = make_nsdm_description(array_type, {.name = name_of(member)});
 new_members.push_back(mem_descr);
 }
 return std::meta::define_class(
 substitute(^struct_of_arrays_impl, {type, N}),
 new_members);
}
template <typename T, size_t N>
using struct_of_arrays = [: make_struct_of_arrays(^T, ^N) :];
struct point {
 float x;
 float y;
 float z;
};
int main() {
 using points = struct_of_arrays<point, 2>;
 points p = {
 .x={1.1, 2.2},
 .y={3.3, 4.4},
 .z={5.5, 6.6}
 };
 static_assert(p.x.size() == 2);
 static_assert(p.y.size() == 2);
 static_assert(p.z.size() == 2);
 for (size_t i = 0; i != 2; ++i) {
 std::cout << "p[" << i << "] = (" << p.x[i] << ", " << p.y[i] << ", " << p.z[i] << ")\n";
 }
}
//输出:
//p[0]=(1.1,3.3,5.5)
//p[1]=(2.2,4.4,6.6)

把当前结构类型的所有非静态数据成员取出来,再根据这些信息重新生成数组形式的成员.
最后生成的points相当于:

using points = struct_of_arrays<point, 2>;
// struct points {
//   std::array x;
//   std::array y;
//   std::array z;
// };

解析命令行选项

再来看一个利用反射仿Rustclap(CommandLineArgumentParser)的实现,clap是Rust的命令行参数解析器.
最终效果为:

struct Args : Clap {
 Option<std::string, {.use_short=true, .use_long=true}> name;
 Option<int, {.use_short=true, .use_long=true}> count = 1;
};
int main(int argc, char** argv) {
 auto opts = Args{}.parse(argc, argv);
 for (int i = 0; i < opts.count; ++i) { //`opts.count`的类型为`int`.
 std::print("Hello {}!", opts.name); //`opts.name`类型为`std::string`
 }
}

示例中定制的Args支持两个参数,一个是name,一个是有默认值的count.如果编译参数为:

./test -n WG21 -c 7

-n就对应于name,-c对应于count.则输出结果将为:

Hello WG21!
Hello WG21!
Hello WG21!
Hello WG21!
Hello WG21!
Hello WG21!
Hello WG21!

可在Args中定制自己的参数列表,在Clap中封装了所有的解析操作.

要实现此效果,先要定义Flags和Option.

struct Flags {
 bool use_short;
 bool use_long;
};
template <typename T, Flags flags>
struct Option {
 std::optional<T> initializer;
 Option() = default;
 Option(T t) : initializer(t) { }
 static constexpr bool use_short = flags.use_short;
 static constexpr bool use_long = flags.use_long;
};

Flags来表示参数,比如短形式为-n,长形式就为--name,可根据不同方式来解析.Option来表示定制的可选参数,有两个构造器,表示可选初化参数值.

比如只写./test -n WG21,此时count提供默认初化为1,从而简化参数.
接着,定义Clap的解析方式:

struct Clap {
 template <typename Spec>
 auto parse(this Spec const& spec, int argc, char** argv) {
 //...
 }
};

这里使用了C++23的推导本作为定制点的表示方式,从而简化传统的CRTP方式.把argc和argv传递进来,下一步操作:

template <typename Spec>
auto Clap::parse(this Spec const& spec, int argc, char** argv) {
 std::vector<std::string_view> cmdline(argv + 1, argv + argc);
 //检查`cmdline`是否包含`--help`等.
 struct Opts;
 static_assert(is_type(spec_to_opts(^Opts, ^Spec)));
 Opts opts;
 //...

如果参数列表为./test -n WG21 -c 7,则除了第一个参数,剩余的实际参数都保存到cmdline中,所以cmdline的大小为4.

接着开始解析,先通过生成代码自动生成Opts类,该类作为解析的结果,也就是auto opts=Args{}.parse(argc,argv);中的opts类型.

根据用户自定义的Args类中的非静态数据成员自动生成该返回类型,生成后的结构为:

struct Opts { std::string name; int count; };

通过spec_to_opts来生成,实现为:

consteval auto spec_to_opts(std::meta::info opts, std::meta::info spec) -> std::meta::info {
 std::vector<std::meta::nsdm_description> new_members;
 for (auto member : nonstatic_data_members_of(spec)) {
 auto new_type = template_arguments_of(type_of(member))[0];
 new_members.push_back(make_nsdm_description(new_type, {.name=name_of(member)}));
 }
 return define_class(opts, new_members);
}

逻辑不算复杂,就是使用前面的nsdm_description和define_class来生成简单类型的代码.

因为不支持扩展语句,因此下一步要借助新Z类型和expand()来遍历参数.

template <typename Spec>
auto Clap::parse(this Spec const& spec, int argc, char** argv) {
 //...
 struct Z {
 std::meta::info spec;
 std::meta::info opt;
 };
 [:std::meta::expand([]() consteval {
 auto spec_members = nonstatic_data_members_of(^Spec);
 auto opts_members = nonstatic_data_members_of(^Opts);
 std::vector<Z> v;
 for (size_t i = 0; i != spec_members.size(); ++i) {
 v.push_back({.spec=spec_members[i], .opt=opts_members[i]});
 }
 return v;
 }()):] >> [&]<auto Z>{
 //...
 }

Z包含两个分别保存Args和Opts的非静态数据成员信息的成员,当前示例它的大小为2.每一组信息就对应一个参数,2个分别对应-n和-c.

如果用扩展语句写,逻辑会更加清晰,对应写法为:

template for (constexpr auto [sm, om] : std::views::zip(nonstatic_data_members_of(^Spec),
 nonstatic_data_members_of(^Opts))) {
 //...
}

具体处理每一组参数的逻辑如下:

template <typename Spec>
auto Clap::parse(this Spec const& spec, int argc, char** argv) {
 //...
 >> [&]<auto Z>{
 constexpr auto sm = Z.spec;
 constexpr auto om = Z.opt;
 auto& cur = spec.[:sm:];
 //查找与此选项关联的参数
 auto it = std::find_if(cmdline.begin(), cmdline.end(),
 [&](std::string_view arg){
 return cur.use_short && arg.size() == 2 && arg[0] == '-' && arg[1] == name_of(sm)[0]
 || cur.use_long && arg.starts_with("--") && arg.substr(2) == name_of(sm);
 });
 if (it == cmdline.end()) {
 //无此参数
 if constexpr (has_template_arguments(type_of(om)) && template_of(type_of(om)) == ^std::optional) {
 //`类型`是可选的,所以参数也是
 return;
 } else if (cur.initializer) {
 //类型不是可选的,但提供了一个可用的初化器.
 opts.[:om:] = *cur.initializer;
 return;
 } else {
 std::cerr << "Missing required option " << name_of(sm) << '\n';
 std::exit(EXIT_FAILURE);
 }
 } else if (it + 1 == cmdline.end()) {
 std::cout << "Option " << *it << " for " << name_of(sm) << " is missing a value\n";
 std::exit(EXIT_FAILURE);
 }
 //好了,找到了参数,试解析一下
 auto iss = std::ispanstream(it[1]);
 if (iss >> opts.[:om:]; !iss) {
 std::cerr << "Failed to parse " << it[1] << " into option " << name_of(sm)
 << " of type " << name_of(type_of(om))
 << '\n';
 std::exit(EXIT_FAILURE);
 }
 };
 return opts;
}

整体实现思路就是,在cmdline参数列表中,根据cur中的信息查找,如果未查到,则看参数是否可选,有默认可选值的,就把该值读取出来,保存到opts中;

如果查找到的位置后面没有紧跟参数值,如-n后面什么也没有,则缺少参数值.

如果找到了参数,则使用C++23std::ispanstream把值读取到opts返回值当中,it查找到的位置为参数的位置,参数位置后面的it[1]就是参数值的位置.
如此便借助反射实现了一个可定制的Clap,逻辑还是比较清晰的,但受限于当前的实现,绕了一些弯路,稍微麻烦了一些.

完整实现为:

//库
namespace clap {
 struct Flags {
 bool use_short;
 bool use_long;
 };
 template <typename T, Flags flags>
 struct Option {
 std::optional<T> initializer;
 Option() = default;
 Option(T t) : initializer(t) { }
 static constexpr bool use_short = flags.use_short;
 static constexpr bool use_long = flags.use_long;
 };
 consteval auto spec_to_opts(std::meta::info opts, std::meta::info spec) -> std::meta::info {
 std::vector<std::meta::nsdm_description> new_members;
 for (auto member : nonstatic_data_members_of(spec)) {
 auto new_type = template_arguments_of(type_of(member))[0];
 new_members.push_back(make_nsdm_description(new_type, {.name=name_of(member)}));
 }
 return define_class(opts, new_members);
 }
 struct Clap {
 template <typename Spec>
 auto parse(this Spec const& spec, int argc, char** argv) {
 std::vector<std::string_view> cmdline(argv + 1, argv + argc);
 //检查`cmdline`是否包含`--help`等.
 struct Opts;
 static_assert(is_type(spec_to_opts(^Opts, ^Spec)));
 Opts opts;
 struct Z {
 std::meta::info spec;
 std::meta::info opt;
 };
 [:std::meta::expand([]() consteval {
 auto spec_members = nonstatic_data_members_of(^Spec);
 auto opts_members = nonstatic_data_members_of(^Opts);
 std::vector<Z> v;
 for (size_t i = 0; i != spec_members.size(); ++i) {
 v.push_back({.spec=spec_members[i], .opt=opts_members[i]});
 }
 return v;
 }()):] >> [&]<auto Z>{
 constexpr auto sm = Z.spec;
 constexpr auto om = Z.opt;
 auto& cur = spec.[:sm:];
 //查找与此选项关联的参数
 auto it = std::find_if(cmdline.begin(), cmdline.end(),
 [&](std::string_view arg){
 return cur.use_short && arg.size() == 2 && arg[0] == '-' && arg[1] == name_of(sm)[0]
 || cur.use_long && arg.starts_with("--") && arg.substr(2) == name_of(sm);
 });
 if (it == cmdline.end()) {
 //无此参数
 if constexpr (has_template_arguments(type_of(om)) && template_of(type_of(om)) == ^std::optional) {
 //类型是可选的,所以参数也是
 return;
 } else if (cur.initializer) {
 //该类型不是可选的,但提供了一个可用初化器.
 opts.[:om:] = *cur.initializer;
 return;
 } else {
 std::cerr << "Missing required option " << name_of(sm) << '\n';
 std::exit(EXIT_FAILURE);
 }
 } else if (it + 1 == cmdline.end()) {
 std::cout << "Option " << *it << " for " << name_of(sm) << " is missing a value\n";
 std::exit(EXIT_FAILURE);
 }
 //好了,找到了参数,试解析一下
 auto iss = std::ispanstream(it[1]);
 if (iss >> opts.[:om:]; !iss) {
 std::cerr << "Failed to parse " << it[1] << " into option " << name_of(sm)
 << " of type " << name_of(type_of(om))
 << '\n';
 std::exit(EXIT_FAILURE);
 }
 };
 return opts;
 }
 };
}

小结

若按100%来谈论反射的进度,前两年更新时进度大概在20%-30%,而如今大概到了30%-40%.从本文也可见已更加完善了实现,也全部支持最新语法,其他相关的反射特性也有了平替的丐版实现,虽说还不够简便,也缺少很多功能,但至少能用了.

我想C++反射也是要分几次标准才能真正完善,进度到60%大概可第一次进标准,也就是进C++26.此时会缺少注入源码该强特性,及自定义属性这类辅助特性,只会包含最基本的反射特性.

即使如此,也敲开C++第三阶段元编程大门,绝对会是一个强大的C++新纪元,产生式元编程也会更加流行.