C++：如何在编译时检查常量variant map的类型？

当然可以实现！C++17及以后的模板元编程和constexpr特性刚好能满足你的需求——让常量键值映射的类型检查完全在编译时完成，连运行时开销都没有。下面我给你两种方案，分别对应字符串键和枚举类键的场景，都是纯编译时的实现：

方案一：字符串键的编译时类型安全映射 #

咱们先从字符串键的场景入手，利用std::string_view的编译时特性，结合模板结构体和元组来构建映射，同时做类型校验。

1. 定义基础类型与键值对结构 #

首先我们先限定支持的值类型，然后定义一个能在编译时存储键和对应值类型的结构体，顺便加个静态断言限制值类型：

#include <string_view>
#include <variant>
#include <tuple>
#include <type_traits>

// 限定支持的值类型：这里只允许int和bool，你可以按需扩展
using SupportedValue = std::variant<int, bool>;

// 编译时键值对结构体，绑定字符串键和值类型
template<std::string_view Key, typename T>
struct KeyValuePair {
    // 静态断言：只允许指定的值类型
    static_assert(std::is_same_v<T, int> || std::is_same_v<T, bool>, 
                  "错误：仅支持int和bool类型的值！");
    constexpr static std::string_view key = Key;
    using value_type = T;
    constexpr static value_type value; // 后续特化初始化
};

// 特化结构体，初始化你的具体键值对
template<> constexpr KeyValuePair<"start_time", int>::value_type KeyValuePair<"start_time", int>::value = 2;
template<> constexpr KeyValuePair<"can_abort", bool>::value_type KeyValuePair<"can_abort", bool>::value = false;

2. 构建映射并实现编译时查找函数 #

把上面的键值对打包到std::tuple里，然后写一个constexpr函数来查找键，同时在编译时检查类型是否匹配：

// 编译时常量映射类型
using ConstMap = std::tuple<
    KeyValuePair<"start_time", int>,
    KeyValuePair<"can_abort", bool>
>;

// 编译时查找函数：带键和预期值类型的模板参数
template<std::string_view Key, typename ExpectedType>
constexpr ExpectedType get_value() {
    // 用索引序列遍历元组，查找匹配的键和类型
    auto find_result = [&]<std::size_t... Is>(std::index_sequence<Is...>) {
        return ( (KeyValuePair<Key, ExpectedType>::key == std::get<Is>(ConstMap{}).key) ? 
            &std::get<Is>(ConstMap{}).value : nullptr );
    }(std::make_index_sequence<std::tuple_size_v<ConstMap>>{});

    // 静态断言：键必须存在
    static_assert(find_result != nullptr, "错误：映射中找不到指定的键！");
    // 静态断言：请求的类型必须和映射中的值类型一致
    static_assert(std::is_same_v<decltype(*find_result), ExpectedType>, 
                  "错误：请求的类型与映射中的值类型不匹配！");
    
    return *find_result;
}

编译时验证示例 #

现在你可以测试一下，正确调用会编译通过，错误调用直接触发编译报错：

// 正确调用：编译通过，得到对应值
constexpr int start = get_value<"start_time", int>(); // 值为2
constexpr bool abort = get_value<"can_abort", bool>(); // 值为false

// 错误调用1：类型不匹配，触发编译错误
// constexpr bool wrong_type = get_value<"start_time", bool>();

// 错误调用2：键不存在，触发编译错误
// constexpr int missing_key = get_value<"end_time", int>();

方案二：支持枚举类作为键 #

如果要把枚举类作为键，实现逻辑类似，但查找效率会更高（枚举值是编译时常量，比字符串比较更快）：

1. 定义枚举键与键值对结构 #

// 定义枚举类型的键
enum class ConfigKey {
    StartTime,
    CanAbort
};

// 针对枚举键的键值对结构体
template<ConfigKey Key, typename T>
struct EnumKeyValuePair {
    static_assert(std::is_same_v<T, int> || std::is_same_v<T, bool>, 
                  "错误：仅支持int和bool类型的值！");
    constexpr static ConfigKey key = Key;
    using value_type = T;
    constexpr static value_type value;
};

// 特化初始化枚举键的键值对
template<> constexpr EnumKeyValuePair<ConfigKey::StartTime, int>::value_type EnumKeyValuePair<ConfigKey::StartTime, int>::value = 2;
template<> constexpr EnumKeyValuePair<ConfigKey::CanAbort, bool>::value_type EnumKeyValuePair<ConfigKey::CanAbort, bool>::value = false;

2. 构建映射与查找函数 #

using EnumConstMap = std::tuple<
    EnumKeyValuePair<ConfigKey::StartTime, int>,
    EnumKeyValuePair<ConfigKey::CanAbort, bool>
>;

template<ConfigKey Key, typename ExpectedType>
constexpr ExpectedType get_enum_value() {
    auto find_result = [&]<std::size_t... Is>(std::index_sequence<Is...>) {
        return ( (std::get<Is>(EnumConstMap{}).key == Key && 
                  std::is_same_v<typename std::tuple_element_t<Is, EnumConstMap>::value_type, ExpectedType>) ? 
            &std::get<Is>(EnumConstMap{}).value : nullptr );
    }(std::make_index_sequence<std::tuple_size_v<EnumConstMap>>{});

    static_assert(find_result != nullptr, "错误：键不存在或类型不匹配！");
    return *find_result;
}

编译时验证示例 #

// 正确调用
constexpr int start_enum = get_enum_value<ConfigKey::StartTime, int>();
constexpr bool abort_enum = get_enum_value<ConfigKey::CanAbort, bool>();

// 错误调用：类型不匹配，编译报错
// constexpr bool wrong_enum_type = get_enum_value<ConfigKey::StartTime, bool>();

额外优化：C++20的consteval函数 #

如果你的项目用C++20，可以把查找函数改成consteval，强制它只能在编译时执行，彻底杜绝运行时调用的可能：

template<std::string_view Key, typename ExpectedType>
consteval ExpectedType get_value() {
    // 内部实现和之前的constexpr版本一致
}

这样所有的键查找、类型检查都会在编译阶段完成，任何不符合要求的操作都会直接触发编译错误，完全符合你的需求！

内容的提问来源于stack exchange，提问作者user1819047