如何借助std::variant向量调用正确的函数特化版本

你可以通过编译期元编程结合std::variant的运行时类型索引实现需求，无需额外维护类型标记向量。核心思路是利用variant自带的index()方法获取元素类型的运行时索引，再通过模板生成所有可能的类型组合分支，运行时匹配后调用对应特化函数。

原问题代码（中文整理） #

#include <vector>
#include <variant>

using valType = std::variant<int, unsigned long, float, double>;

// 基础模板
template<typename... Ts>
void func(Ts...);

// 全特化函数
template<>
void func(unsigned long);
template<>
void func(double, double);
template<>
void func(float, double);

int main()
{
    std::vector<valType> values;
    values.emplace_back(float{});
    values.emplace_back(double{});
    
    // 当前做法：依赖额外的类型标记向量判断调用func(float, double)
    // 希望找到更优雅的实现方式
    
    return 0;
}

优雅实现方案 #

以下是两种可行的实现思路，均无需额外类型标记向量：

方案1：编译期生成所有类型组合，运行时匹配索引

适合元素数量固定的场景（比如示例中的2个元素），利用编译期生成所有可能的类型组合分支，运行时通过variant::index()匹配后调用对应函数：

#include <vector>
#include <variant>
#include <tuple>
#include <utility>
#include <iostream>

using valType = std::variant<int, unsigned long, float, double>;
// 保存variant的备选类型列表，用于编译期类型推导
using ValTypes = std::tuple<int, unsigned long, float, double>;

// 基础模板
template<typename... Ts>
void func(Ts...) {
    std::cout << "基础模板调用\n";
}

// 全特化实现
template<>
void func(unsigned long) {
    std::cout << "func(unsigned long) 调用\n";
}
template<>
void func(double, double) {
    std::cout << "func(double, double) 调用\n";
}
template<>
void func(float, double) {
    std::cout << "func(float, double) 调用\n";
}

// 尝试匹配单个类型组合并调用对应func
template<std::size_t I1, std::size_t I2>
void try_call(const std::vector<valType>& vals) {
    if (vals[0].index() == I1 && vals[1].index() == I2) {
        // 若不需要使用值，可替换为std::declval<T>()生成临时对象
        func(std::get<I1>(vals[0]), std::get<I2>(vals[1]));
    }
}

// 生成所有可能的类型组合索引（4种类型×2个元素=16种组合）
template<std::size_t... Is>
void dispatch_2_elements(const std::vector<valType>& vals, std::index_sequence<Is...>) {
    (try_call<Is / 4, Is % 4>(vals), ...);
}

// 对外接口：处理2个元素的variant向量
void process_2_elements(const std::vector<valType>& vals) {
    static_assert(vals.size() == 2, "需传入恰好2个元素的向量");
    dispatch_2_elements(vals, std::make_index_sequence<4*4>());
}

int main() {
    std::vector<valType> values1{float{}, double{}};
    process_2_elements(values1); // 输出：func(float, double) 调用
    
    std::vector<valType> values2{double{}, double{}};
    process_2_elements(values2); // 输出：func(double, double) 调用
    
    return 0;
}

方案2：利用类型标签传递类型信息（无需访问variant值）

如果完全不需要使用variant内部的值，仅需类型信息，可以定义类型标签结构体，通过std::visit提取元素类型后匹配调用：

#include <vector>
#include <variant>
#include <iostream>

using valType = std::variant<int, unsigned long, float, double>;

// 类型标签：仅用于传递类型信息
template<typename T>
struct TypeTag {};

// 基于类型标签的函数重载（替代原全特化）
void func(TypeTag<unsigned long>) {
    std::cout << "func(unsigned long) 调用\n";
}
void func(TypeTag<double>, TypeTag<double>) {
    std::cout << "func(double, double) 调用\n";
}
void func(TypeTag<float>, TypeTag<double>) {
    std::cout << "func(float, double) 调用\n";
}

// 从variant中提取对应类型的标签
template<typename T>
TypeTag<T> get_type_tag(const T&) {
    return {};
}

// 调度函数：根据类型标签调用对应func
template<typename T1, typename T2>
void dispatch(const std::vector<valType>& vals) {
    func(
        std::visit(get_type_tag<decltype(std::declval<T1>())>, vals[0]),
        std::visit(get_type_tag<decltype(std::declval<T2>())>, vals[1])
    );
}

// 遍历所有类型组合并尝试匹配
void process_2_elements(const std::vector<valType>& vals) {
    static_assert(vals.size() == 2, "需传入恰好2个元素的向量");
    using Types = std::tuple<int, unsigned long, float, double>;
    // 遍历所有类型组合（借助编译期索引序列）
    [&]<std::size_t... I1, std::size_t... I2>(std::index_sequence<I1...>, std::index_sequence<I2...>) {
        ((vals[0].index() == I1 && vals[1].index() == I2) ? 
            dispatch<std::tuple_element_t<I1, Types>, std::tuple_element_t<I2, Types>>(vals) : void(), ...);
    }(std::make_index_sequence<4>{}, std::make_index_sequence<4>{});
}

int main() {
    std::vector<valType> values{float{}, double{}};
    process_2_elements(values); // 输出：func(float, double) 调用
    return 0;
}

方案说明 #

• 两种方案均无需维护额外的类型标记向量，直接从std::variant的index()方法获取类型信息。
• 编译期生成所有可能的类型组合，避免了手动编写大量if-else判断分支。
• 若元素数量不固定，可扩展为递归式调度器，但需注意类型组合数随元素数量指数增长（比如3个元素时为4³=64种组合），编译时间会相应增加，适合类型数量少、元素数量固定的场景。

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