C++中如何实现枚举值到对应模板实例类型的映射容器？

我定义了如下枚举类：

enum class color { Red, Green, Blue, /* etc. */};

以及类模板：

template <color Color> class foo;

现在需要声明一种数据类型，能为部分或全部color枚举值存储对应类型为foo<Color>的值，并且支持运行时插入和移除映射关系。需求类似std::unordered_map<color, foo>，但要求指定color值对应的必须是foo<Color>类型，而非任意foo实例。

目前想到的方案是用tuple（或包装std::optional）：

using MyMap = std::tuple<std::optional<foo<color::Blue>>, std::optional<foo<color::Red>>, std::optional<foo<color::Green>>>;

并编写编译期getter：

template <color Color>
std::optional<foo<Color>> get(const MyMap& map)
{ return std::get<std::optional<foo<Color>>>(map); }

但这种方式比较繁琐，有没有更优实现？

备注：

• 部分color无对应映射时，行为不限：可抛异常、返回nullopt，或仅支持编译期初始化的结构。
• 可使用C++20及以上版本，优先常规方案。

方案1：基于std::variant的运行时类型安全映射 #

核心思路是用std::variant统一所有foo<Color>类型的存储，搭配std::unordered_map实现运行时映射，同时封装类型安全的访问接口。

实现代码 #

// 统一所有foo<Color>类型的变体集合
using FooVariant = std::variant<foo<color::Red>, foo<color::Green>, foo<color::Blue>>;

// 类型安全的映射容器
class ColorFooMap {
private:
    std::unordered_map<color, FooVariant> storage_;

public:
    // 插入：仅接受对应color的foo实例，编译期检查类型匹配
    template <color Color>
    void insert(foo<Color> value) {
        storage_[Color] = std::move(value);
    }

    // 获取：类型安全，返回optional包装的常量引用
    template <color Color>
    std::optional<std::reference_wrapper<const foo<Color>>> get() const {
        auto it = storage_.find(Color);
        if (it == storage_.end()) return std::nullopt;
        // 用std::get保证类型匹配，不匹配时抛出bad_variant_access
        try {
            return std::cref(std::get<foo<Color>>(it->second));
        } catch (const std::bad_variant_access&) {
            return std::nullopt;
        }
    }

    // 移除指定color的映射
    void erase(color c) {
        storage_.erase(c);
    }
};

优缺点 #

• 优点：完全支持运行时插入/移除，接口直观；编译期检查插入类型合法性，无类型错误风险；无需提前固定所有存储的color，扩展性好。
• 缺点：需要预先把所有可能的foo<Color>类型加入FooVariant，枚举扩展时需同步更新变体定义。

方案2：编译期索引的tuple增强版 #

针对你最初的tuple方案做简化，利用C++20的编译期特性自动生成容器并简化访问逻辑，适合所有映射的color能在编译期确定的场景。

实现代码 #

// 编译期生成对应color的foo可选值元组
template <color... Colors>
struct ColorFooTuple {
    using Type = std::tuple<std::optional<foo<Colors>>...>;
};

// 定义支持Red/Green/Blue的映射类型
using MyMap = ColorFooTuple<color::Red, color::Green, color::Blue>::Type;

// 简化的类型安全getter
template <color TargetColor, color... Colors>
std::optional<foo<TargetColor>>& get(std::tuple<std::optional<foo<Colors>>...>& tuple) {
    return std::get<std::optional<foo<TargetColor>>>(tuple);
}

// const版本重载
template <color TargetColor, color... Colors>
const std::optional<foo<TargetColor>>& get(const std::tuple<std::optional<foo<Colors>>...>& tuple) {
    return std::get<std::optional<foo<TargetColor>>>(tuple);
}

优缺点 #

• 优点：编译期类型检查严格，无运行时类型开销；访问速度极快（直接元组索引）。
• 缺点：无法运行时动态添加新color的映射，所有支持的color必须在编译期确定；枚举扩展时需手动更新ColorFooTuple的模板参数。

方案3：C++26 std::flat_map优化版（可选） #

如果可以使用C++26，std::flat_map比unordered_map有更好的缓存性能，仅替换方案1的底层存储即可，接口完全一致：

class ColorFooMap {
private:
    std::flat_map<color, FooVariant> storage_;
    // 其余接口同方案1
};

• 需要运行时动态扩展映射的color值：优先方案1
• 所有映射的color可在编译期确定，且追求极致性能：优先方案2
• 使用C++26且关注缓存效率：方案3是方案1的性能优化版

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