带可调用参数的模板特化未按预期工作

首先得明确你遇到的问题根源：VS2015的模板部分特化匹配规则有局限性，你写的Dispatch<TemplateA<int>>实例化时，编译器优先匹配了主模板的可变参数版本（把TemplateA<int>作为第一个模板参数，剩余参数为空），而非你预期的TemplateA<T>特化，导致调用dp1()时，主模板的operator()需要传入可调用对象和参数，自然就报了“无法作为无参函数调用”的错误。加上VS2015不支持C++17的std::invoke和std::is_invokable，得用旧标准兼容的方式解决。

先把你给出的完整代码片段贴出来方便分析：

#include <type_traits>
template <typename> class TemplateA {};
struct Callable { void operator()() {}; };
template <typename F, typename... Args>
struct Dispatch {};

// 针对TemplateA实例的特化
template <typename T>
struct Dispatch<TemplateA<T>> {
    void operator()() {}
};

// 针对可调用对象的特化
template <typename F, typename... Args>
struct Dispatch<F, Args...> {
    void operator()(F&& f, Args&&... args) {
        f(std::forward<Args>(args)...);
    }
};

int main() {
    TemplateA<int> ta;
    Dispatch<TemplateA<int>> dp1;
    dp1(); // 报错：term does not evaluate to a function taking 0 arguments

    Callable c;
    Dispatch<Callable> dp2;
    dp2(c);
    return 0;
}

方案一：给可调用特化添加SFINAE约束 #

我们可以自己实现一个简易的“无参可调用类型”判断，然后用std::enable_if给可调用对象的特化加上约束，让它只匹配真正能无参调用的类型，这样TemplateA的特化就能正常匹配了：

1. 实现简易的可调用类型判断
   用SFINAE特性，通过检测类型是否能执行无参调用，来判断是否为可调用类型：

// 辅助模板：判断类型是否支持无参调用
template <typename F, typename = void>
struct is_callable_noarg : std::false_type {};

template <typename F>
struct is_callable_noarg<F, decltype(std::declval<F>()(), void())> : std::true_type {};

2. 修改Dispatch的特化逻辑
   把针对可调用对象的特化改成带约束的版本，只有当类型满足无参可调用时才会匹配这个特化，否则优先匹配TemplateA的特化：

#include <type_traits>
template <typename> class TemplateA {};
struct Callable { void operator()() {}; };

// 辅助模板：判断无参可调用类型
template <typename F, typename = void>
struct is_callable_noarg : std::false_type {};

template <typename F>
struct is_callable_noarg<F, decltype(std::declval<F>()(), void())> : std::true_type {};

template <typename F, typename... Args>
struct Dispatch {};

// TemplateA的特化：精确匹配，优先级更高
template <typename T>
struct Dispatch<TemplateA<T>> {
    void operator()() {}
};

// 可调用对象的特化：添加SFINAE约束，只匹配无参可调用类型
template <typename F>
struct Dispatch<F, typename std::enable_if<is_callable_noarg<F>::value>::type> {
    void operator()(F&& f) {
        f();
    }
};

// 如果需要支持带参数的调用，可以扩展如下特化
template <typename F, typename... Args>
struct Dispatch<F, Args..., typename std::enable_if<!std::is_base_of<TemplateA<typename std::decay<Args>::type>, F>::value>::type> {
    void operator()(F&& f, Args&&... args) {
        f(std::forward<Args>(args)...);
    }
};

修改后，main里的dp1()就能正常匹配Dispatch<TemplateA<int>>的特化，不会再报错了。

方案二：改用标签分发（更稳定的旧编译器方案） #

如果觉得模板特化的优先级问题太折腾，标签分发是旧编译器下更可靠的选择，绕开特化匹配的坑：

#include <type_traits>
template <typename> class TemplateA {};
struct Callable { void operator()() {}; };

// 定义标签类型，用于区分不同的处理逻辑
struct TemplateATag {};
struct CallableTag {};

// 类型标签判断：给不同类型分配对应的标签
template <typename T>
struct get_tag {
    using type = CallableTag; // 默认给可调用类型分配标签
};

template <typename T>
struct get_tag<TemplateA<T>> {
    using type = TemplateATag; // TemplateA实例分配专门的标签
};

// 针对不同标签的处理实现
template <typename T>
void dispatch_impl(T&& obj, TemplateATag) {
    // 这里写TemplateA类型的处理逻辑
}

template <typename F, typename... Args>
void dispatch_impl(F&& f, CallableTag, Args&&... args) {
    f(std::forward<Args>(args)...);
}

// 对外统一接口
template <typename T, typename... Args>
void Dispatch(T&& t, Args&&... args) {
    using Tag = typename get_tag<typename std::decay<T>::type>::type;
    dispatch_impl(std::forward<T>(t), Tag{}, std::forward<Args>(args)...);
}

int main() {
    TemplateA<int> ta;
    Dispatch(ta); // 匹配TemplateA的处理逻辑

    Callable c;
    Dispatch(c); // 匹配可调用对象的处理逻辑
    return 0;
}

这种方式通过标签明确指定要调用的处理函数，完全避开了模板特化的优先级问题，在VS2015下兼容性拉满。

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