C++26反射特性下的编译时常量映射与可变变量

consteval {

...contents...

}

template <typename T>
struct A;
constexpr auto refl_1 = ^^A<int>;
constexpr auto refl_2 = substitute(^^A, {
                                            ^^int});
static_assert(refl_1 == refl_2);  // 使用 substitute 与手动编写相同
// 示例 1

struct A;     // 不完整类型
struct B {};  // 完整类型
static_assert(is_complete_type(^^A) == false);
static_assert(is_complete_type(^^B) == true);
// 示例 2

template <typename>
struct A;  // 不完整的类模板
template <>
struct A<int> {};  // 完整的显式模板特化
template <>
struct A<long>;  // 不完整的显式模板特化
static_assert(is_complete_type(^^A<long>) == false);
static_assert(is_complete_type(^^A<char>) == false);
static_assert(is_complete_type(^^A<int>) == true);
// 示例 3

struct A;
static_assert(is_complete_type(^^A) == false);
consteval {
    define_aggregate(^^A, {
                          });  // 完成类型
}
static_assert(is_complete_type(^^A) == true);
// 示例 4a

struct A;
static_assert(is_complete_type(^^A) == false);
struct A {};  // 完成类型
static_assert(is_complete_type(^^A) == true);
// 示例 4b

template <typename>
struct A;
consteval {
    define_aggregate(^^A<int>, {
                               });
}
static_assert(is_complete_type(^^A<int>) == true);
static_assert(is_complete_type(^^A<char>) == false);
// 示例 5a

template <typename>
struct A;
template <>
struct A<int> {};
static_assert(is_complete_type(^^A<int>) == true);
static_assert(is_complete_type(^^A<char>) == false);
// 示例 5b

struct A1;
consteval {
    define_aggregate(^^A1, {
                               data_member_spec(^^int, {
                                                           .name = "value"})});
}
struct A2 {
    int value;
};
// 示例 6

consteval{
   TU_Ticket::increment();
}
constexpr int a = TU_Ticket::latest();
static_assert(a == 1);
consteval{
   TU_Ticket::increment();
}
constexpr int b = TU_Ticket::latest();
static_assert(b==2);
// 示例 7a

template <>
struct Helper<TU_Ticket::latest()> {};
constexpr int a = TU_Ticket::latest();
static_assert(a == 1);
template <>
struct Helper<TU_Ticket::latest()> {};
constexpr int b = TU_Ticket::latest();
static_assert(b == 2);
// 示例 7b

template <int N>
struct Helper;
struct TU_Ticket {
    static consteval int latest() {
        int k = 0;
        while (is_complete_type(substitute(^^Helper, {
                                                         std::meta::reflect_constant(k)})))
            ++k;
        return k;
    }

    static consteval void increment() {
        define_aggregate(substitute(^^Helper,
                                    {
                                        std::meta::reflect_constant(latest())}),
                         {});
    }
};
consteval {
    TU_Ticket::increment();  // 增加一次
    TU_Ticket::increment();  // 增加两次
}
static_assert(is_complete_type(^^Helper<0>) ==
              true);  // 类已完整，0 不是当前值
static_assert(is_complete_type(^^Helper<1>) ==
              true);  // 类已完整，1 不是当前值
static_assert(is_complete_type(^^Helper<2>) ==
              false);  // 类不完整！2 是当前值，无需进一步搜索
static_assert(TU_Ticket::latest() == 2);

template<auto>
    struct storage;
    template<meta::info v>
    struct info_as_type{
        static constexpr meta::info value = v;
    };
    // 示例 1a

template<meta::info key, meta::info value>
    consteval void insert(){
        meta::info refl = substitute(^^storage,{reflect_constant(key)});
        define_aggregate(refl,{data_member_spec(^^info_as_type<value>,{.name = "value"})});
    }
    // 示例 1b

template<meta::info key>
    consteval meta::info at(){
        constexpr meta::info refl = substitute(^^storage,{reflect_constant(key)});
        return decltype([:refl:]::value)::value;
    }
    // 示例 1c

template<meta::info storage>
struct CT_map{
    template<meta::info v>
    struct info_as_type{
        static constexpr meta::info value = v;
    };
    template<meta::info key, meta::info value>
    static consteval void insert(){
        meta::info refl = substitute(storage,{reflect_constant(key)});
        define_aggregate(refl,{data_member_spec(^^info_as_type<value>,{.name = "value"})});
    }
    template<meta::info key>
    static consteval meta::info at(){
        constexpr meta::info refl = substitute(storage,{reflect_constant(key)});
        return decltype([:refl:]::value)::value;
    }
    static consteval bool contains(meta::info key){
        meta::info refl = substitute(storage,{reflect_constant(key)});
        return is_complete_type(refl);
    }
    // 示例 2a

template<auto>
    struct storage;
    using map = CT_map<^^storage>;
    static_assert(map::contains(^^int) == false);
    consteval{
        map::insert<^^int,^^char>();
    }
    static_assert(map::at<^^int>() == ^^char);
    static_assert(map::contains(^^int) == true);
    // 示例 2b

using ::example_2::CT_map;

    template<auto>
    struct storage;
    using map1 = CT_map<^^storage>;
    static_assert(map1::contains(^^int) == false);
    consteval{
        map1::insert<^^int,^^char>(); // 向 map1 插入一对键值
    }
    static_assert(map1::contains(^^int) == true);
    using map2 = CT_map<^^storage>;
    static_assert(map2::at<^^int>() == ^^char); // map2 将其视为自己的键值对
    // 示例 3

template<meta::info storage, meta::info unique_key = ^^void>
struct CT_map{
    template<meta::info v>
    struct info_as_type{
        static constexpr meta::info value = v;
    };
    template<meta::info key, meta::info value>
    static consteval void insert(){
        meta::info refl = substitute(storage,{reflect_constant(pair<meta::info,meta::info>{unique_key,key})});
        define_aggregate(refl,{data_member_spec(^^info_as_type<value>,{.name = "value"})});
    }
    template<meta::info key>
    static consteval meta::info at(){
        constexpr meta::info refl = substitute(storage,{reflect_constant(pair<meta::info,meta::info>{unique_key,key})});
        return decltype([:refl:]::value)::value;
    }
    static consteval bool contains(meta::info key){
        meta::info refl = substitute(storage,{reflect_constant(pair<meta::info,meta::info>{unique_key,key})});
        return is_complete_type(refl);
    }
    // 示例 4a

template<auto>
    struct storage;
    using map1 = CT_map<^^storage, reflect_constant(1)>;
    static_assert(map1::contains(^^int) == false);
    consteval{
        map1::insert<^^int,^^char>(); // 创建特化 storage<{^^1,^^int}>
    }
    static_assert(map1::at<^^int>() == ^^char); // 搜索特化 storage<{^^1,^^int}>
    static_assert(map1::contains(^^int) == true);

    using map2 = CT_map<^^storage, reflect_constant(2)>;
    static_assert(map2::contains(^^int) == false); // 搜索特化 storage<{^^2,^^int}>
    consteval{
        map2::insert<^^int,^^long>(); // 创建特化 storage<{^^2,^^int}>
    }
    static_assert(map2::at<^^int>() == ^^long); // 搜索特化 storage<{^^2,^^int}>
    static_assert(map2::contains(^^int) == true);
    // 示例 4b

template<meta::info storage, meta::info unique_key = ^^void, int Hint = 100>
struct CMV{
   using map = CT_map<storage,unique_key>;
   ...
};

static consteval int latest(){
   int l=0, r = Hint;
   while(map::contains(reflect_constant(r))) r*=r;
   while(l<r){
   int mid = (l+r)/2;
   if(map::contains(reflect_constant(mid))){
           l=mid+1;
       }else{
           r = mid;
       }
   }
   return l-1;
}

template<int index = latest()>
static consteval meta::info get(){
   return map::template at<reflect_constant(index)>();
}

template<meta::info value, int index = latest() + 1>
static consteval void set(){
   map::template insert<reflect_constant(index),value>();
}

template<auto>
struct storage;
using var = CMV<^^storage>;
static_assert(var::latest() == -1); // CMV is empty
consteval{
   var::set<^^int>(); // set var to ^^int
}
static_assert(var::latest() == 0);
static_assert(var::get() == ^^int); // get var's value
consteval{
   var::set<^^char>();
}
static_assert(var::latest() == 1);
static_assert(var::get() == ^^char); // get var's value
consteval{
   var::set<^^long>();
}
static_assert(var::latest() == 2);
static_assert(var::get() == ^^long); // get var's value
static_assert(var::get<0>() == ^^int); // get a previous value of var

template <meta::info storage, meta::info unique_key = ^^void, int Hint = 100>
struct MCT_map {
   template <meta::info key>
   using CMV_T =
       CMV<storage, reflect_constant(std::pair<meta::info, meta::info>{unique_key, key}), Hint>;
   template <meta::info key, meta::info value, int index = CMV_T<key>::latest()>
   static consteval void insert() {
       CMV_T<key>::template set<value>();
   }
   template <meta::info key, int index = CMV_T<key>::latest()>
   static consteval meta::info at() {
       return CMV_T<key>::template get<>();
   }
};

这里有一个使用可变编译时映射的示例：

上面的代码可以在 [godbolt](https://godbolt.org/z/ovqE3xsaq)[5] 上找到。

正如你现在所理解的，这些方法依赖于创建模板特化来存储状态。大多数示例所做的工作都可以通过普通的显式模板特化和宏来完成，以隐藏样板代码。反射使我们能够做到没有它无法实现的两件事。

首先，它允许我们将所有模板、类型和值作为键和值存储在一个类中。如果没有反射，每次我们需要不同的类型作为键和值时，就必须创建一个特殊的映射类。具体来说，为了拥有所有可能的类型和值（非类型）映射组合（类型到类型映射、类型到值映射、值到类型映射和值到值映射），我们需要 4 种不同编码的类。而且，每当我们想使用模板到其他或反之亦然的映射时，就需要一个新的映射类。相反，通过保存反射，我们只需拥有一个值到值的映射，当我们需要原始元素时，只需解析反射即可。

其次，由于我们使用 `define_aggregate` 函数创建了一个完整的类模板特化，因此可以在编译期间有条件地选择是否完成特化。没有反射这是不可能实现的。`#if` 指令无法实现这一点，因为它在预处理阶段执行，而不是在编译期间执行。这意味着 `#if` 不能依赖编译期间获取的任何信息，例如类型信息或常量的值，它只能使用其他宏。在编译期间轻松且有条件地保存状态对于有状态的元编程非常有用。

我希望你能理解这些方法是易于理解、信息丰富且有趣的。我相信这些方法对元编程很有用，希望你能利用反射来提高代码的性能、可读性、可维护性和安全性。

最后，我为你提供了一个 [链接](https://github.com/Alexey-Saldyrkine/compile_time_tools)[6]，这是一个我创建的存储库，其中包含之前描述的类及其测试，以及通用枚举和编译时随机数生成器。

1.   “C++26 的反射” P2996R13 ([https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2996r13.html](https://www.open-std.org/jtc1/sc22/wg21/docs/papers/2025/p2996r13.html))
2.   编译时票证计数器示例 ([https://godbolt.org/z/on4xMe338](https://godbolt.org/z/on4xMe338))
3.   编译时映射示例 ([https://godbolt.org/z/ac4zbjzx8](https://godbolt.org/z/ac4zbjzx8))
4.   编译时可变变量示例 ([https://godbolt.org/z/KhT155Psf](https://godbolt.org/z/KhT155Psf))
5.   可变编译时映射示例 ([https://godbolt.org/z/ovqE3xsaq](https://godbolt.org/z/ovqE3xsaq))
6.   通用枚举和编译时随机数生成器存储库 ([https://github.com/Alexey-Saldyrkine/compile_time_tools](https://github.com/Alexey-Saldyrkine/compile_time_tools))
7.   所有示例代码的存储库 ([https://github.com/Alexey-Saldyrkine/CT-map-and-mutable-variable-example-code](https://github.com/Alexey-Saldyrkine/CT-map-and-mutable-variable-example-code))