Reflection for C++26
岁月如驰，距前篇反射文章，已近两载。
C++23 工作殆尽，C++26 紧随其后，Relection 也有了一些新进展，本篇来看这些更新的些许内容。
相关作者
知识似树，发枝散叶，往往只需两三人而已。欲了解一个领域，先知悉其中的几位关键人物，由此扩散挖掘，便可以快速理解该领域 80% 以上的内容。
是以本节介绍一下 SG7 中 Reflection 相关的研究人员。
先从 Wyatt Childers 说起，他是 Lock3 Software 的软件工程师，主要就是研究实现静态反射和元编程。lock3 版本的反射就是他们写的，在 C++ 反射 第四章 标准 中便是使用的这一版本进行示例编写。
而 Lock3 Software 公司的创始人是 Andrew Sutton，此人就是 C++20 Concepts 提案的作者，也是 GCC Concepts 的主要开发人员。他于 2010-2013 年间曾以博士后研究员的身份加入 TAMU（Texas A&M University），而 Bjarne Stroustrup 于 2002-2014 年间在 TAMU 担任计算机科学主席教授，两人就此相识。自 2012 年 Andrew Sutton 参与并实现 Concepts 之后，他便开始重度参与静态反射和元编程的设计与实现。
Barry Revzin 则是比较活跃的一位 C++ 标准委员会成员，参与过众多标准提案，比如 C++23 Deducing this、if consteval、Formatting Ranges、ranges::fold、views::join_with、views::as_rvalue 等等。他也写过许多文章，参加过一些演讲，大家曾经肯定读过他的某些文章。
Peter Dimov 是 Boost 的活跃成员，编写并维护了许多库，例如 Assert、Bind、Describe、Lambda2、Mp11、SmartPtr、Variant2，许多库后面都进了 C++11 标准，如 shared_ptr、weak_ptr、enable_shared_from_this、bind 等等。Describe 就是 Boost 当中的一个 C++14 反射库，在 C++ 反射 第二章 探索 中也介绍过。
Faisal Vali，他也是比较早期的一位贡献者，基本一直有参与静态反射的工作。他参与的比较有名的特性应该是 C++17 CTAD 和 Constexpr Lambda。
Daveed Vandevoorde，这位也是 C++ 的早期贡献者，90 年代初便发明了各种基于模板的编程技术，并带到了 C++。早些年 C++ 模板参数必须在尖括号之间额外写一个空格，如 list<complex<double> >，后来不再必须，便是他的一个小贡献。他也是 C++ Templates – The Complete Guide 的主要作者，谁还没读过这本书呢？
因此，欲了解 Static Reflection，主要就是围绕这几人的相关论文和演讲进行，其中又以 Andrew Sutton 和 Wyatt Childers 的论文为主要资料，其他人的论文作为进一步挖掘的补充资料。
新的变化
与上次内容相比，本次更新并没有显著变化。
我觉得最大的变化在于实现上的新进展。之前使用的是 lock3 的反射版本，但那个已数年不曾更新，不支持最新的反射语法。而本次 EDG(Edison Design Group) 基于 P2996 对最新的反射提供了支持，新的语法已然生效。EDG 就是 Daveed Vandevoorde 所在的公司，他是主要技术领导之一，该公司专门研发编译器相关的技术。
因此新的提案提供了许多反射的使用示例，在应用方面更加全面。
尽管如此，EDG 的反射版本并不像 lock3 那样，支持并驾齐驱的几个元编程特性，例如 Expansion statements 和 Soure code injection，它只是在反射特性上有了更新的实现。虽然也有平替方式，但是功能上要弱化许多，而且不甚方便。
基础内容本篇不再赘述，请阅读 C++ 反射 第四章 标准，本篇接下来将介绍大量实践内容。
新的环境
新的 EDG Experimental Reflection 可以直接在 https://godbolt.org/z/beT7ao7h1 使用，以下的所有示例也全部基于该版本实现。
默认使用 C++23，头文件只需要包含 #include <experimental/meta>，所有元函数都在 std::meta 下面。
下面是一个最简单的例子：
#include <experimental/meta>
int main() {
constexpr auto r = ^int;
typename[:r:] x = 42; // Same as: int x = 42;
typename[:^char:] c = '*'; // Same as: char c = '*';
}这里展示了 reflection 和 splicing 操作，在 lock3 版本时，囿于实现，没能使用这种最新的反射语法，而如今已经可以使用，所以 EDG Reflection 使用起来反而比 lock3 简单。
下面看更多使用例子，都是提案中的，由于例子已经很多，额外补充的不在本篇讲。
Selecting Members
这是一个操纵成员的小例子：
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; // Same as: s.j = 42;
s.[:member_number(5):] = 0; // Error (member_number(5) is not a constant).
}通过 lifting(reflection) operator 先返回反射类型 meta::info，再通过 splicing 重新得到成员类型，从而访问成员。
List of Types to List of Sizes
类型列表转换为类型大小列表：
constexpr std::array types = {^int, ^float, ^double};
// the consteval is required here because consteval propagation (P2564) is not yet implemented
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));这个例子同样很简单，不多讲，最终 sizes 的内容就相当于：
std::array<std::size_t, 3> sizes = {sizeof(int), sizeof(float), sizeof(double)};Implementing make_integer_sequence
通过反射来简化实现 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>;
}这两个元函数用于将 Constant value(s) lifting 为反射类型(meta::info)表示，比如：
constexpr std::vector<int> v{ 1, 2, 3 };
constexpr std::span<std::meta::info> rv = reflect_values(v);随后，便可以将这个 lifted sequence 重新 Splicing 出来使用，如作为模板参数使用：
std::integer_sequence<int, ...[:rv:]...> is123;
// same as std::integer_sequence<int, 1, 2, 3>以上仅是示例，EDG Reflection 尚不支持 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; // Type X<int, int>, which selects the specialization.
// There is no mechanism to instantiate a primary template
// definition that is superseded by an explicit/partial
// specialization.根据 X<int, int, float> 生成了新的类型 X<int, int>。
但是，EDG 目前有些局限，它使用 std::vector<info> 来代替 std::span<info const>，因此
substitute(^std::integer_sequence, args);中才使用 std::vector<info> 来作为参数。
Getting Class Layout
使用反射来获取类布局信息：
struct member_descriptor
{
std::size_t offset;
std::size_t size;
bool operator==(member_descriptor const&) const = default;
};
// returns std::array<member_descriptor, N>
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 目前不支持 Expansion statements，所以增加了一些实现的复杂度。如果使用 Expansion statements，核心语句将可以这样实现：
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 对 Expansion statements 的临时平替，实现为：
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);
}例子中其他使用的元函数皆顾名思义，逻辑清晰，不再多讲。
Enum to String
最经典的例子，相当于反射界的 Hello world。
过去的文章中已经展示了各种实现，最经典的当属标准的版本：
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 "<unnamed>";
}
enum Color { red, green, blue };
static_assert(enum_to_string(Color::red) == "red");
static_assert(enum_to_string(Color(42)) == "<unnamed>");及反操作版本：
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 不支持 Expansion statements，所以使用 expand() 代替：
template<typename E>
requires std::is_enum_v<E>
constexpr std::string enum_to_string(E value) {
std::string result = "<unnamed>";
[: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)) == "<unnamed>");这种实现的复杂度为 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 "<unnamed>";
}
}这种方式借助 std::map 来实现，曾经在 C++ 反射 第二章 探索 也介绍过。
A Simple Tuple Type
与传递递归继承实现法相比，一种更简单的 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 当前并不支持 Source code injection，所以他们提供了丐版的替代元函数 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 接受一个 Incomplete class/struct/union 和非静态数据成员的反射元信息序列（由 nsdm_description 的返回值构成），这些非静态数据成员将注入到将生成的类型里面。这就是 Source code injection 的基本能力，弱化版的实现。
举个例子：
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<int> is now defined to the equivalent of
// template<> struct S<int> {
// 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):];
}通过反射，可以直接操纵类型元信息，不再需要额外的奇技淫巧去递归地获取这些信息。
Struct to Struct of Arrays
这也是一个代码生成的例子：
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";
}
}
// Output:
// p[0] = (1.1, 3.3, 5.5)
// p[1] = (2.2, 4.4, 6.6)使用的都是之前介绍过的元函数，逻辑也很清晰，就是把当前结构体类型的所有非静态数据成员获取出来，再根据这些信息重新生成数组形式的成员。
最后生成的 points 相当于：
using points = struct_of_arrays<point, 2>;
// equivalent to:
// struct points {
// std::array<float, 2> x;
// std::array<float, 2> y;
// std::array<float, 2> z;
// };Parsing Command-Line Options
再来看一个利用反射仿 Rust clap(Command Line Argument Parser) 的实现，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 has type int
std::print("Hello {}!", opts.name); // opts.name has type 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 Deducing this 作为定制点表示方式，从而简化传统的 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);
// check if cmdline contains --help, etc.
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 来完成简单类型的代码生成工作。
因为不支持 Expansion statements，因此下一步需要借助新类型 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。
如果用 Expansion statements 写，逻辑则会更加清晰，对应的写法为：
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:];
// find the argument associated with this option
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()) {
// no such argument
if constexpr (has_template_arguments(type_of(om)) && template_of(type_of(om)) == ^std::optional) {
// the type is optional, sot he argument is too
return;
} else if (cur.initializer) {
// the type isn't optional, but an initializer is provided, use that
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);
}
// alright, found our argument, try to parse it
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;
}整体实现思路就是根据 cur 中的信息在参数列表 cmdline 中查找，如果没有查到，则看参数是否可选，有可选默认值的，把该值读取出来，保存到 opts 中；如果查找到的位置后面没有紧跟参数值，如 -n 后面什么也没有，则缺少参数值。
如果找到了参数，则使用 C++23 std::ispanstream 将值读取到 opts 返回值当中，it 查找到的位置为参数的位置，参数位置后面 it[1] 就是参数值的位置。
如此便借助反射实现了一个可定制的 Clap，逻辑还是比较清晰的，但受限于当前的实现，绕了一些路，显得麻烦了一些。
完整实现为：
// The Library
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);
// check if cmdline contains --help, etc.
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:];
// find the argument associated with this option
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()) {
// no such argument
if constexpr (has_template_arguments(type_of(om)) && template_of(type_of(om)) == ^std::optional) {
// the type is optional, sot he argument is too
return;
} else if (cur.initializer) {
// the type isn't optional, but an initializer is provided, use that
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);
}
// alright, found our argument, try to parse it
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。此时会缺少 Source code injection 这种强特性，以及 Custom Attributes 这类辅助特性，只会包含最基本的反射特性。
即使如此，也将敲开 C++ 第三阶段元编程的大门，绝对会是一个强大的 C++ 新纪元，产生式元编程也将更加流行。
