SFINAE无法正确禁用模糊重载：C++17下灵活版std::equal_to实现问题排查

你的代码遇到的核心问题是：SFINAE条件依赖的是类模板的静态常量，而非函数模板自身的模板参数，导致类实例化阶段就检测到重载冲突，根本没进入到函数模板的SFINAE筛选环节。

为什么原来的代码会报错？ #

当你实例化FlexibleEqualsTo<int, int>时，类模板的静态常量cmpT1toT2和cmpT2toT1在类实例化阶段就被确定为true了。此时编译器看到两个operator()函数模板的签名（移除enable_if修饰后）完全一致：

template<class Dummy>
constexpr bool operator()(const Dummy& lhs, const int& rhs)

编译器在处理类模板成员时，会先检查所有成员模板的声明合法性——这两个模板的参数列表和函数参数结构完全相同，因此被判定为重载冲突，直接报错，不会等到后续调用时再用SFINAE筛选。

更简洁的C++17解决方案：if constexpr #

既然你用的是C++17，完全可以利用if constexpr的编译时分支特性，只写一个operator()，避免重载冲突：

#include <vector>
#include <utility>
#include <functional>
#include <type_traits>

// 保留你的检测结构体
template<class FromT, class ToT, class Dummy = void>
struct EqualityOperatorDefined : std::false_type {};

template<class FromT, class ToT>
struct EqualityOperatorDefined <FromT, ToT, decltype(std::declval<FromT>() == std::declval<ToT>())> : std::true_type {};

template<class T1, class T2>
class FlexibleEqualsTo {
private:
    static constexpr bool cmpT1toT2 = EqualityOperatorDefined<T1, T2>::value;
    static constexpr bool cmpT2toT1 = EqualityOperatorDefined<T2, T1>::value;
public:
    constexpr bool operator()(const T1& lhs, const T2& rhs) const {
        // 静态断言确保至少有一个相等运算符可用
        static_assert(cmpT1toT2 || cmpT2toT1, 
                      "No valid equality operator exists between T1 and T2");
        
        if constexpr (cmpT1toT2) {
            return lhs == rhs;
        } else {
            // 此时cmpT2toT1必然为true
            return rhs == lhs;
        }
    }
};

// 测试用例
int main() {
    FlexibleEqualsTo<int, int> eq_int;
    static_assert(eq_int(5, 5));
    
    // 自定义类型测试
    struct A {};
    struct B {
        bool operator==(const A&) const { return true; }
    };
    
    FlexibleEqualsTo<B, A> eq_ba;
    static_assert(eq_ba(B{}, A{}));
    
    FlexibleEqualsTo<A, B> eq_ab;
    static_assert(eq_ab(A{}, B{}));
}

如果你坚持要用重载方案 #

如果一定要通过重载实现，需要让SFINAE条件依赖函数模板自身的模板参数，这样编译器在类实例化阶段无法确定条件结果，会推迟到函数模板重载决议时再进行SFINAE筛选：

template<class T1, class T2>
class FlexibleEqualsTo {
public:
    // 把检测逻辑移到函数模板的依赖参数中
    template<class Dummy = T1>
    std::enable_if_t<EqualityOperatorDefined<T1, T2>::value, bool>
    constexpr operator()(const T1& lhs, const T2& rhs) const {
        return lhs == rhs;
    }

    template<class Dummy = T1>
    std::enable_if_t<!EqualityOperatorDefined<T1, T2>::value && EqualityOperatorDefined<T2, T1>::value, bool>
    constexpr operator()(const T1& lhs, const T2& rhs) const {
        return rhs == lhs;
    }
};

这种方式虽然可行，但代码冗余度更高，远不如if constexpr方案简洁直观。

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