随着静态反射（Reflection）如愿成为 C++26 标准的一部分，C++ 标准库也提供了 std::define_static_array() 帮助我们在编译期将一个 range 提升为程序静态数据段的数组常量，尤其是在 constexpr 运算逻辑较为复杂的时候可以有效避免样板代码量以及元编程带来的编译期时空开销。然而，由于 std::define_static_array() 的内部实现原理是将被提升的元素全部作为 constexpr 模板变量的非类型模板参数（NTTP），因此可以被 std::define_static_array() 直接提升的类型也必须符合 NTTP 的全部限制，即元素类型必须为 structural：要么是 C++ 基本类型，要么只能是所有成员均为 public 且递归满足 structural 性质的结构体或联合体。但在实际开发中，我们更多是与非 structural 类型打交道，比如 std::define_static_array() 自己的返回类型 std::span<const T> 就不是 structural（其成员变量均为私有），这就导致 std::define_static_array() 自身难以胜任处理嵌套 range 的进阶任务。本文将介绍如何通过 C++26 强大的反射能力，并借助一些简易的标准库替代品，有效地扩展 std::define_static_array() 的数据提升能力，让更多原本非 structural 的类型（甚至是复杂的嵌套类型）也能顺利提升为编译期常量。

本文所述内容作为笔者实现的 rbox 库的核心组件之一。rbox::to_static_storage() 的实现源代码已在 GitHub 开源。

成果展示

扩展后的 rbox::to_static_storage() 能够处理结构体内复杂的嵌套 range。提升后的数据类型中，rbox::meta_span 和 rbox::meta_string_view 分别为标准库 std::span 和 std::string_view 的 structural 替代品。自身不满足 structural 性质的结构体类型（例如代码示例中的 graph_t）会被提升为 struct rbox::structural_mirror_t<graph_t>，该类型通过 C++26 标准库提供的 std::meta::define_aggregate() 定义。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
struct adj_list_item_t {
    size_t target_index;
    double edge_weight;
};

struct graph_t {
    std::vector<double> node_weights;
    std::vector<std::string> node_labels;
    std::vector<std::vector<adj_list_item_t>> adjacency_list;
};

// Type of promoted_graph is rbox::structural_mirror_t<graph_t>, which is defined as {
//     rbox::meta_span<double> node_weights;
//     rbox::meta_span<rbox::meta_string_view> node_labels;
//     rbox::meta_span<rbox::meta_span<adj_list_item_t>> adjacency_list;
// };
constexpr auto promoted_graph = rbox::to_static_storage(graph_t{ /* ... */ });

// Type of promoted_graphs is rbox::meta_span<rbox::structural_mirror_t<graph_t>>
constexpr auto promoted_graphs = rbox::to_static_storage(std::vector<graph_t>{ /* ... */ });

预备知识：什么是 Structural，为什么 std::define_static_array() 需要它

根据 C++ 标准，非类型模板参数（NTTP）必须为如下类型之一，满足该约束的类型被 C++ 标准称为 structural（仅在 C++20 及后续标准支持的用蓝色标识，仅在 C++26 及后续标准支持的用深绿色标识）：

  • 算术类型：整数、浮点数；
  • 枚举类型；
  • 指针（指向静态数据段的变量）以及 std::nullptr_t；
  • 左值引用（指向静态数据段的变量）；
  • 成员指针；
  • 不含捕获变量（即：可以转换为函数指针类型）的 Lambda 表达式；
  • Literal class type，即符合以下全部约束的 class 或 union：
    1. 所有基类均为 public 并且递归地满足 structural 约束；
    2. 所有非静态成员变量均为 public、non-volatile、non-mutable；
    3. 对于 class，所有非静态成员变量均为 structural 类型或者 structural 类型的数组（含高维数组）；对于 union，至少一个非静态成员变量为 structural 类型或者 structural 类型的数组（含高维数组）；
    4. 存在至少一个 constexpr 构造函数；
  • std::meta::info。

举例说明：std::pair<int, int> 或者自己定义的 struct pair_t { int x, y; }; 均符合 structural 约束，因此其实例可以作为 NTTP；但 std::tuple<int, int> 就不行，因为 std::tuple 的成员变量不是 public；std::pair<int, std::tuple<int, int>> 也不行，因为其成员变量 second 不属于 structural 类型。

我们在简介部分提到过，std::define_static_array() 的内部实现原理是将被提升的元素全部作为 constexpr 模板变量的非类型模板参数（NTTP）。C++ 标准库内部定义了一个数组模板 __fixed_array，将所有模板参数 Vs... 写到一个 C-style 数组内。C++26 标准库提供了另一个提升 range 数据的组件 std::meta::reflect_constant_array()，它通过 std::meta::substitute() 生成 __fixed_array 的实例，将 range 内的全部数据作为 NTTP 传进去。而 std::define_static_array() 其实就是对 std::meta::reflect_constant_array() 的简单封装，通过 std::meta::extract() 提取出该数组的头指针，然后将其打包为 std::span。既然 range 内的数据最终被反射为 __fixed_array 的 NTTP，那么元素类型必须为 structural 的限制也在情理之中了。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
// From: https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2025/p3491r3
template <typename T, T... Vs>
inline constexpr T __fixed_array[sizeof...(Vs)]{Vs...};  // Internal array

template <std::ranges::input_range R>
consteval auto reflect_constant_array(const R& range) -> std::meta::info
{
    using T = std::ranges::range_value_t<R>;
    auto args = std::vector<std::meta::info>{^^T};
    for (auto&& elem : range) {
        args.push_back(std::meta::reflect_constant(elem));
    }
    return substitute(^^__fixed_array, args);  // std::meta::substitute found via ADL
}

template <std::ranges::input_range R>
consteval auto define_static_array(const R& range) -> std::span<std::ranges::range_value_t<R> const>
{
    using T = std::ranges::range_value_t<R>;
    // Produce the array.
    auto array = reflect_constant_array(range);
    // Turn the array into a span. std::meta::{extract, extent, type_of} are found via ADL.
    return std::span<T const>(extract<T const*>(array), extent(type_of(array)));
}

嵌套 range 的第一步：std::span 的 Structural 替代品

由于 std::span 的成员变量均为私有，因此其不满足 structural 约束，这就导致 std::define_static_array() 处理嵌套 range 时，内层提升后得到的 std::span 数组不能通过 std::define_static_array() 继续提升。其解决方案非常直截了当，我们手动实现一个 std::span 的替代品并使其满足 structural 约束，然后对 std::define_static_array() 作二次封装，将其返回的 std::span 转换为我们自己的 structural 版本。笔者的 rbox 库提供了 rbox::meta_span，它就是一个简单的结构体 { const T* head; size_t n; } 外加一些与标准库对应的成员函数。类似地，笔者也提供了 rbox::meta_string_view 作为 std::string_view 的 structural 替代品，于是 std::vector<std::string> 可以被递归地提升为 rbox::meta_span<rbox::meta_string_view>。

p.s. 虽然 std::define_static_string() 返回的 const CharT* 已经满足了 structural 约束，但在 rbox 库的 API 设计中，笔者还是倾向于用 string-view 将字符串的长度记录下来，以少量的空间开销换取运行时性能提升。

到这里我们可以实现一个 to_static_storage(input) 的初版：如果 input 是一个元素类型为字符的 range，就将 input 提升为 rbox::meta_string_view；如果 input 是其他 range，则对其每个元素递归地调用 to_static_storage()；否则，直接返回 input（其余复杂情形此处暂时略过，我们将在下文介绍）。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
template <class T>
consteval auto to_static_storage(const T& input)
{
    if constexpr (std::ranges::input_range<T>) {
        // (1) Range
        using V = std::ranges::range_value_t<T>;
        if constexpr (char_type<V>) {
            const auto* c_str = std::define_static_string(input);
            return meta_basic_string_view{c_str};
        } else {
            auto elementwise = input | std::views::transform([](const auto& value) {
                return to_static_storage(value);
            });
            auto span = std::define_static_array(elementwise);
            return meta_span{span.data(), span.size()};
        }
    } else {
        // Otherwise: identity
        return input;
    }
}

处理复杂的结构体：生成其 Structural 镜像类型

真实的案例往往比嵌套 range 更加复杂。回到“成果展示”一节中的 graph_t 案例，我们现在具备了逐一提升其成员变量的能力，但对 graph_t 本身还需要一层手动包装，才能让其中的数据保持结构体的组织形式。我们仍然需要手动实现一个 static_graph_t ，把 graph_t 的所有成员变量复制粘贴过去，逐一修改其类型；最后提升 graph_t 整体时对每个成员逐一调用 to_static_storage()。也就是说，graph_t 中的每个成员变量还要被手工重复至少两次，对 graph_t 成员变量的増删也要被重复至少两次，这些冗余代码和多出来的维护成本正是我们希望通过 C++26 反射消除的。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
struct graph_t {
    std::vector<double> node_weights;
    std::vector<std::string> node_labels;
    std::vector<std::vector<adj_list_item_t>> adjacency_list;
};

struct static_graph_t {
    rbox::meta_span<double> node_weights;
    rbox::meta_span<rbox::meta_string_view> node_labels;
    rbox::meta_span<rbox::meta_span<adj_list_item_t>> adjacency_list;
};

consteval auto promote_graph(const graph_t& G) -> static_graph_t
{
    return {
        .node_weights = rbox::to_static_storage(G.node_weights),
        .node_labels = rbox::to_static_storage(G.node_labels),
        .adjacency_list = rbox::to_static_storage(G.adjacency_list),
    };
}

从根本上说，我们的目标是将 graph_t 自动变换为与之对应的 structural 版本，变换后每个成员变量都是变换前同名成员的“镜像类型”，用于装载该成员使用 to_static_storage() 提升的结果。C++26 提供了一个强大的工具 std::meta::define_aggregate() ，用于在编译期使用 constexpr 表达式定义一个结构体类型。典型的使用场景就是对已有结构体进行变换得到一个新类型，C++26 反射草案（也就是著名的 P2996）中也包含了诸如“Struct to Struct of Arrays”（见草案原文第 3.10 节）等经典案例。std::meta::define_aggregate() 接收两个参数 type_class 和 specs，前者表示一个此时未定义的 class 或 union 类型，后者表示我们要在 type_class 中添加哪些成员变量。specs 列表中每个元素都是 std::meta::data_member_spec(type, options) 的返回值，type 为该成员变量的类型，options 则用于指定该成员变量的名称、对齐、位域的比特长度，以及是否被属性 [[no_unique_address]] 修饰，且必须满足下列全部约束：

  1. name 必须为合法的 C++ 标识符；除非该成员变量是匿名位域，否则 name 必须提供；
  2. 若 alignment 未提供，则该成员的对齐量取默认值，即与 type 保持一致；否则 alignment 必须为 2 的非负整数次幂，且不得低于 type 自身的对齐量；
  3. 若 bit_width 有值，则表示该成员为位域，此时 bit_width 必须为非负整数，同时 type 必须为整型或枚举类型，alignment 不得有值，no_unique_address 必须为 false；若 bit_width == 0，则 name 也不得有值。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
namespace std::meta {
  struct data_member_options {
    optional<name_type> name;  // name_type is constructible from string or u8string
    optional<int> alignment;
    optional<int> bit_width;
    bool no_unique_address = false;
  };

  consteval auto data_member_spec(info type, data_member_options options) -> info;

  template <reflection_range R = initializer_list<info>>
  consteval auto define_aggregate(info type_class, R&& specs) -> info;
}

// Example of usage
struct T;  // Currently an incomplete type

consteval {
    // std::meta::{define_aggregate, data_member_spec} found via ADL
    define_aggregate(^^T, {
        data_member_spec(^^int, {.name = "x"}),
        data_member_spec(^^int, {.name = "y", .alignment = 8}),
        data_member_spec(^^unsigned, {.name = "flags", .bit_width = 10}),
    });
    // Now T is a complete type which is defined as struct {
    //     int x;
    //     alignas(8) int y;
    //     unsigned flags : 10;
    // };
}

给定给构体 T，我们利用 std::meta::define_aggregate() 生成 T 的镜像类型。通过 std::meta::nonstatic_data_members_of() 获取 T 的非静态成员列表，使用 std::meta::type_of() 逐个获取每个成员变量的类型 U，并将 U 变换为 to_static_storage() 的结果类型；成员变量的命名保持不变。成员变量的类型变换通过别名模板 to_static_storage_result_t 完成，在 constexpr 表达式内我们借助 std::meta::substitute() 实例化该模板。生成的镜像类型定义到 structural_mirror<T>::type 内。

需要注意：

  1. std::meta::nonstatic_data_members_of() 只能获取由类型 T 自身直接定义的成员变量。在实际应用中，还需要递归地获取来自基类的成员。rbox 库的内部实现包含了将所有类成员进行“平铺”（Flatten）的预处理机制（实现细节见 rbox 源代码），为行文方便此处略去对类继承的处理；
  2. std::meta::nonstatic_data_members_of() 除了结构体类型 T 以外，还需要一个 std::meta::access_context 类型的参数 ctx，用于控制每个成员变量的访问权限。unprivileged() 只能访问到 public 成员，unchecked() 可以无限制地访问全部成员，current() 对应的权限则与其调用位置保持一致。rbox 库的 API 设计会直接拒绝掉包含 protected 或 private 成员变量（包括来自基类的成员）的类型，为行文方便此处略去相关细节。
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
namespace impl {
consteval auto make_structural_mirror_members(std::meta::info T) -> std::vector<std::meta::info>
{
    auto ctx = std::meta::access_context::unprivileged();
    // std::meta::{nonstatic_data_members_of, type_of, identifier_of} and
    // std::meta::{substitute, data_member_spec} found via ADL.
    auto members = nonstatic_data_members_of(T, ctx);
    auto n = members.size();

    auto res = std::vector<std::meta::info>(n);
    for (auto i = 0zU; i < n; i++) {
        auto U = type_of(members[i]);
        auto name = identifier_of(members[i]);

        // S reflects to_static_storage_result_t<U>
        auto S = substitute(^^to_static_storage_result_t, {U});
        res[i] = data_member_spec(S, {.name = name});
    }
    return res;
}
}  // namespace impl

template <class T>
using to_static_storage_result_t = decltype(to_static_storage(std::declval<T>()));

template <class T>
struct structural_mirror {
    class type;

    consteval {
        // std::meta::define_aggregate found via ADL
        define_aggregate(^^type, impl::make_structural_mirror_members(^^T));
    }
};

template <class T>
using structural_mirror_t = typename structural_mirror<T>::type;

得到结构体的 structural 镜像之后，to_static_storage() 的实现也就水到渠成。令 n 表示输入结构体的成员变量个数，只需要依次将输入的第 i 个成员提升之后赋值给镜像类型的第 i 个成员。C++26 的 template for 语法可以让我们干净利落地实现该过程，配合 C++ Ranges 提供的 iota_view（ 以及 C++26 进一步引入的 std::views::indices ），它能代替 std::make_index_sequence<N>() 生成 0 ~ N-1 的常量列表，无需模板元编程和辅助函数的介入。

不过很不幸，以下基于 template for 的实现虽然简洁但无法支持 T 的成员变量包含引用的情况：T 包含的引用会在镜像后的 R 中原样保留，此时无法将 result 先初始化为 R{} 然后对其成员逐一赋值，只能一次性 R{...} 初始化完毕。所以 rbox 库实际的实现还是退回了传统的 std::make_index_sequence<N>()。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
template <class T>
consteval auto to_static_storage(const T& input)
{
    if constexpr (std::ranges::input_range<T>) {
        // (1) Range. Omitted here ...
    } else if constexpr (/* T is non-structural class type which is mirrorable */) {
        // (2) Mirrorable struct
        using R = structural_mirror_t<T>;
        constexpr size_t N = nonstatic_data_members_of(^^T).size();

        auto result = R{};
        // for I = 0 to N-1, with each I being constexpr
        template for (constexpr auto I : std::views::indices(N)) {
            constexpr std::meta::info from = nonstatic_data_members_of(^^T)[I];
            constexpr std::meta::info to = nonstatic_data_members_of(^^R)[I];
            result.[:to:] = to_static_storage(input.[:from:]);
        }
        return result;
    } else {
        // Otherwise: identity
        return input;
    }
}