如何在C++编译期实现add_to_map以构建类型映射并验证一致性？

要实现你想要的编译期类型映射验证，核心思路是利用模板元编程和编译期字符串，在每次注册键-类型对时检查是否存在冲突。以下是基于C17的完整解决方案，也会提及C20的简化方案。

核心步骤说明 #

1. 编译期字符串支持：C++17没有原生编译期std::string，所以我们先定义一个轻量的ConstString结构体来存储编译期字符串。
2. 编译期条目与映射：用SettingEntry存储单个键-类型对，用std::tuple作为编译期类型映射的容器。
3. 冲突检查逻辑：通过constexpr lambda遍历映射，检查是否存在相同键但不同类型的条目，冲突时触发static_assert。
4. 注册接口封装：将检查逻辑封装到add_to_map函数中，供set_setting和get_setting调用，自动触发编译期验证。

完整代码实现 #

1. 基础工具定义（C++17兼容） #

#include <tuple>
#include <string>
#include <map>
#include <any>
#include <algorithm>

// 编译期字符串结构体（C++17替代std::string_view编译期支持）
template <size_t N>
struct ConstString {
    constexpr ConstString(const char (&str)[N]) noexcept {
        std::copy_n(str, N, value);
    }
    char value[N];
    constexpr size_t size() const noexcept { return N - 1; }
    constexpr bool operator==(const ConstString& other) const noexcept {
        if (size() != other.size()) return false;
        for (size_t i = 0; i < size(); ++i) {
            if (value[i] != other.value[i]) return false;
        }
        return true;
    }
};
// 模板推导指引，让编译器自动推导字符串长度
template <size_t N> ConstString(const char (&)[N]) -> ConstString<N>;

// 模拟C++20的std::type_identity，用于存储类型信息
template <typename T>
struct type_identity { using type = T; };

// 单个键-类型条目
template <ConstString Key, typename T>
struct SettingEntry {
    static constexpr auto key = Key;
    using type = T;
};

// 空的初始映射
using EmptySettingMap = std::tuple<>;

2. 编译期冲突检查与映射更新 #

// 编译期函数：检查并添加条目到映射
template <typename Map, ConstString Key, typename T>
constexpr auto add_entry(Map) {
    // 检查是否存在相同键但不同类型的冲突
    constexpr bool has_conflict = []{
        bool conflict = false;
        // 用折叠表达式遍历tuple中的每个条目
        [&]<size_t... Is>(std::index_sequence<Is...>) {
            (([&]{
                using Entry = std::tuple_element_t<Is, Map>;
                if (Entry::key == Key && !std::is_same_v<typename Entry::type, T>) {
                    conflict = true;
                }
            }()), ...);
        }(std::make_index_sequence<std::tuple_size_v<Map>>{});
        return conflict;
    }();

    // 冲突时触发编译错误
    static_assert(!has_conflict, "Error: Setting key already registered with a different type");

    // 检查条目是否已存在（键和类型都匹配）
    constexpr bool entry_exists = []{
        bool exists = false;
        [&]<size_t... Is>(std::index_sequence<Is...>) {
            (([&]{
                using Entry = std::tuple_element_t<Is, Map>;
                if (Entry::key == Key && std::is_same_v<typename Entry::type, T>) {
                    exists = true;
                }
            }()), ...);
        }(std::make_index_sequence<std::tuple_size_v<Map>>{});
        return exists;
    }();

    // 已存在则返回原映射，否则添加新条目
    if constexpr (entry_exists) {
        return Map{};
    } else {
        return std::tuple_cat(Map{}, std::tuple<SettingEntry<Key, T>>{});
    }
}

// 累积式映射模板：每次添加条目都会生成新的映射类型
template <ConstString Key, typename T, typename PreviousMap = EmptySettingMap>
struct SettingMap {
    // 继承之前的映射，确保所有历史条目都被检查
    using type = decltype(add_entry(PreviousMap{}, Key, T));
};

3. 对外接口实现 #

// 编译期注册函数：触发类型检查
template <size_t N, typename T>
constexpr void add_to_map(const char (&key)[N], T) {
    // 实例化SettingMap，自动触发编译期检查
    using CurrentMap = typename SettingMap<ConstString<N>(key), T>::type;
    // 这里不需要使用CurrentMap，只要实例化就会执行所有检查逻辑
}

// 设置配置（运行期存储+编译期类型验证）
template <size_t N, typename T>
void set_setting(const char (&key)[N], T value) {
    add_to_map(key, value);
    // 运行期存储配置值（示例用std::map+std::any）
    static std::map<std::string, std::any> settings_store;
    settings_store[std::string(key)] = std::move(value);
}

// 获取配置（编译期类型验证+运行期取值）
template <typename T, size_t N>
T get_setting(const char (&key)[N]) {
    add_to_map(key, T{});
    static std::map<std::string, std::any> settings_store;
    return std::any_cast<T>(settings_store.at(std::string(key)));
}

4. 测试示例 #

int main() {
    set_setting("pi", 3.14);          // ✅ 合法：注册"pi"为double
    set_setting("answer", 42);        // ✅ 合法：注册"answer"为int
    auto ans = get_setting<int>("answer"); // ✅ 合法：匹配已注册类型
    set_setting("pi", 3.0);           // ✅ 合法：类型仍为double
    // set_setting("answer", 42.0);   // ❌ 编译错误："answer"已注册为int
    // auto pi_bool = get_setting<bool>("pi"); // ❌ 编译错误："pi"注册为double
}

C++20简化方案 #

C++20支持std::string_view作为非类型模板参数，我们可以去掉自定义的ConstString，直接用std::string_view：

// 替换ConstString为std::string_view
template <std::string_view Key, typename T>
struct SettingEntry {
    static constexpr auto key = Key;
    using type = T;
};

// 调整add_to_map的模板参数
template <std::string_view Key, typename T>
constexpr void add_to_map() {
    using CurrentMap = typename SettingMap<Key, T>::type;
}

template <std::string_view Key, typename T>
void set_setting(T value) {
    add_to_map<Key, T>();
    static std::map<std::string, std::any> settings_store;
    settings_store[Key.data()] = std::move(value);
}

// 调用方式更简洁：
set_setting<"pi">(3.14);
auto ans = get_setting<int, "answer">();

关键说明 #

• 编译期检查：所有类型冲突检查都在编译阶段完成，不会影响运行期性能。
• 键的硬编码要求：必须使用编译期常量字符串作为键（如字面量），无法使用运行期生成的字符串，这是编译期验证的必要条件。
• 运行期存储：示例中用std::map<std::string, std::any>存储运行期值，你可以根据需求替换为其他容器（如unordered_map）。

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