如何在编译时判断多次函数调用是否指向同一函数以优化std::visit

核心思路 #

你不需要对比函数指针，只要遍历std::variant的所有备选类型，逐一枚举验证该类型作为参数传入visitor时，最终选择的重载、以及调用的返回值类型完全一致，只要所有备选项都满足这个条件，就可以跳过动态分发直接调用对应重载。

具体实现步骤 #

1. 提取visitor对指定类型的调用签名和返回值 #

首先定义工具元函数，用来获取visitor接受某个类型参数时的调用结果类型，以及判断两个类型调用visitor是不是走到同一个重载：

// 元函数：获取visitor调用T类型参数的返回值类型
template <typename Visitor, typename T>
using visit_result_t = decltype(std::declval<Visitor>()(std::declval<T&>())); // 按左值引用场景为例，可扩展const、右值等重载

// C++17及以上可用的判断：两个类型调用visitor是不是匹配同一个重载，且返回值一致
template <typename Visitor, typename T1, typename T2>
constexpr bool is_same_overload_v = 
    std::is_same_v<visit_result_t<Visitor, T1>, visit_result_t<Visitor, T2>>
    && requires(Visitor v, T1& t1, T2& t2) {
        // 检查两个调用对应实例的签名一致，兼容无捕获lambda、普通函数、仿函数
        requires std::is_same_v<
            decltype(std::declval<Visitor>()(std::declval<T1&>())),
            decltype(std::declval<Visitor>()(std::declval<T2&>()))
        >;
    };

2. 遍历variant所有备选类型做一致性校验 #

将std::variant的所有备选类型展开，检查第一个类型的调用结果，和后面所有类型的调用结果都满足is_same_overload_v即可：

template <typename Visitor, typename Variant>
struct all_same_overload;

template <typename Visitor, typename... Ts>
struct all_same_overload<Visitor, std::variant<Ts...>> {
    static constexpr bool value = []<std::size_t... Is>(std::index_sequence<Is...>) {
        if constexpr (sizeof...(Ts) == 0) return true;
        else {
            using FirstT = std::tuple_element_t<0, std::tuple<Ts...>>;
            return (is_same_overload_v<Visitor, FirstT, Ts> && ...);
        }
    }(std::make_index_sequence<sizeof...(Ts)>{});
};

template <typename Visitor, typename Variant>
constexpr bool all_same_overload_v = all_same_overload<Visitor, Variant>::value;

3. 集成到visit实现的分支判断 #

在你的std::visit实现入口处，先判断all_same_overload_v<Visitor, Variant>是否为true，是的话直接取出variant的存储地址转成对应参数类型调用visitor，不需要走下标跳转的动态分发逻辑：

template <typename Visitor, typename Variant>
decltype(auto) optimized_visit(Visitor&& vis, Variant&& var) {
    using VarType = std::decay_t<Variant>;
    if constexpr (all_same_overload_v<std::decay_t<Visitor>, VarType>) {
        // 直接调用，无需动态分发
        using FirstMatchT = std::tuple_element_t<0, typename VarType::types>;
        return std::forward<Visitor>(vis)(*reinterpret_cast<std::add_pointer_t<std::conditional_t<
            std::is_const_v<std::remove_reference_t<Variant>>,
            std::add_const_t<FirstMatchT>,
            FirstMatchT
        >>>(var.data()));
    } else {
        // 走原有的动态分发逻辑
        // ...
    }
}

注意事项 #

• 上述示例中的重载判断默认兼容无捕获的lambda、普通函数、仿函数，若要支持带捕获的lambda，可将判断逻辑调整为验证所有备选类型参数都可隐式转换到visitor第一个可匹配的重载参数类型即可
• 上面的实现默认只处理非const左值引用的variant参数，你可以扩展到const、右值引用等所有值类型的场景
• 如果visitor是带有模板调用运算符的泛型lambda，只要所有参数实例化后的调用返回值和行为一致，该判断也能正常生效
• 不需要处理函数指针相等的问题，通过调用签名的类型一致性判断就可以覆盖隐式转换（比如你提到的Derived转Base的场景）

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