使用整数数组元素获取std::variant内容编译失败，求解决方案

std::get<N>(std::variant) 的模板参数 N 必须是编译期常量表达式——编译器在编译阶段就需要明确这个索引值，才能确定要从variant中取出的具体类型。而你的代码里，循环变量i是运行时才会确定的值，哪怕expected_types是constexpr数组，expected_types[i]在循环中属于运行时计算结果，无法作为模板参数传入std::get，这就是编译报错No matching function to call 'get'的核心原因。

另外你代码里存在笔误：std::get<my_type[i]>应该是std::get<expected_types[i]>，但即使修正这个，本质问题还是模板参数不是编译期常量。

针对你提到的多类（A/B/C）有固定预期类型格式的场景，下面给出两种清晰优雅的实现方式：

方式一：编译期常量序列 + 模板展开（类型安全，推荐） #

这种方式把每个类的预期类型索引转为编译期常量序列，通过模板折叠表达式展开验证逻辑，完全避免运行时分支开销，类型安全性拉满。

1. 实现通用验证工具 #

#include <variant>
#include <vector>
#include <utility>
#include <type_traits>

using my_type = std::variant<int, float, bool>;

// 验证单个variant是否匹配指定索引的类型，并将值转为bool
template<std::size_t N>
bool validate_single(const my_type& var) {
    if (var.index() != N) return false; // 类型不匹配直接返回false
    
    return std::visit([](auto&& val) -> bool {
        // 根据实际需求调整类型转bool的逻辑
        if constexpr (std::is_same_v<std::decay_t<decltype(val)>, bool>) {
            return val;
        } else {
            // 非bool类型按"非零为true"转换
            return static_cast<bool>(val);
        }
    }, var);
}

// 展开编译期序列，批量验证所有元素
template<std::size_t... Is>
bool validate_sequence(const std::vector<my_type>& input, std::index_sequence<Is...>) {
    if (input.size() != sizeof...(Is)) return false;
    // 折叠表达式：只要有一个元素验证为true，结果就为true
    return (validate_single<Is>(input[Is]) || ...);
}

2. 各业务类实现foo接口 #

每个类直接用std::index_sequence声明自己的预期类型索引，逻辑清晰：

class A {
public:
    bool foo(const std::vector<my_type>& input) {
        // A预期类型：int(0), int(0), bool(2)
        return validate_sequence(input, std::index_sequence<0, 0, 2>{});
    }
};

class B {
public:
    bool foo(const std::vector<my_type>& input) {
        // B预期类型：int(0), int(0), float(1)
        return validate_sequence(input, std::index_sequence<0, 0, 1>{});
    }
};

class C {
public:
    bool foo(const std::vector<my_type>& input) {
        // C预期类型：bool(2), bool(2)
        return validate_sequence(input, std::index_sequence<2, 2>{});
    }
};

方式二：运行时动态检查（灵活兼容场景） #

如果需要支持运行时动态修改预期类型（你的场景不需要，但可作为补充方案），可以用运行时数组存储预期索引，结合std::variant::index()和std::visit实现：

#include <variant>
#include <vector>

using my_type = std::variant<int, float, bool>;

bool validate_dynamic(const std::vector<my_type>& input, const std::vector<std::size_t>& expected_types) {
    if (input.size() != expected_types.size()) return false;
    
    bool rst = false;
    for (std::size_t i = 0; i < input.size(); ++i) {
        const auto& var = input[i];
        if (var.index() != expected_types[i]) continue;
        
        rst = rst || std::visit([](auto&& val) -> bool {
            if constexpr (std::is_same_v<std::decay_t<decltype(val)>, bool>) {
                return val;
            } else {
                return static_cast<bool>(val);
            }
        }, var);
    }
    return rst;
}

// 各业务类实现
class A {
public:
    bool foo(const std::vector<my_type>& input) {
        static const std::vector<std::size_t> expected = {0, 0, 2};
        return validate_dynamic(input, expected);
    }
};

class B {
public:
    bool foo(const std::vector<my_type>& input) {
        static const std::vector<std::size_t> expected = {0, 0, 1};
        return validate_dynamic(input, expected);
    }
};

class C {
public:
    bool foo(const std::vector<my_type>& input) {
        static const std::vector<std::size_t> expected = {2, 2};
        return validate_dynamic(input, expected);
    }
};

• std::variant::index()返回的是当前存储类型在variant模板参数列表中的位置：my_type中int对应0，float对应1，bool对应2，要确保预期索引和这个对应关系一致。
• std::visit中用if constexpr处理类型分支，能在编译期消除无效分支，避免运行时类型判断开销。

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