如何实现禁止参数隐式转换的严格Callable签名匹配？

C++17 实现方案 #

要实现严格的签名匹配（禁止隐式转换、严格匹配参数数量与类型），核心思路是直接提取目标可调用对象的原生签名，再与期望的返回值、参数类型做逐一对齐的严格对比，而非依赖std::is_invocable这类允许隐式转换的特性。

实现代码 #

#include <type_traits>
#include <tuple>

// 辅助 trait：提取可调用对象的签名信息
template<typename F>
struct get_signature;

// 处理普通函数类型
template<typename Ret, typename... Args>
struct get_signature<Ret(Args...)> {
    using return_type = Ret;
    using args_tuple = std::tuple<Args...>;
    static constexpr std::size_t arity = sizeof...(Args);
};

// 处理函数指针
template<typename Ret, typename... Args>
struct get_signature<Ret(*)(Args...)> : get_signature<Ret(Args...)> {};

// 处理非const成员函数指针
template<typename Class, typename Ret, typename... Args>
struct get_signature<Ret(Class::*)(Args...)> : get_signature<Ret(Args...)> {};

// 处理const成员函数指针
template<typename Class, typename Ret, typename... Args>
struct get_signature<Ret(Class::*)(Args...) const> : get_signature<Ret(Args...)> {};

// 处理lambda（含捕获的lambda，通过提取operator()的签名）
template<typename F>
struct get_signature : get_signature<decltype(&F::operator())> {};

// 辅助变量模板简化调用
template<typename F>
using return_type_t = typename get_signature<F>::return_type;

template<typename F>
using args_tuple_t = typename get_signature<F>::args_tuple;

template<typename F>
constexpr std::size_t arity_v = get_signature<F>::arity;

// 核心严格签名匹配函数
template <class Foo, class Ret, class... Args>
static constexpr auto sigmatch() {
    // 第一步：检查参数数量是否一致
    if constexpr (arity_v<Foo> != sizeof...(Args)) {
        return false;
    }
    // 第二步：检查返回类型是否完全相同
    else if constexpr (!std::is_same_v<return_type_t<Foo>, Ret>) {
        return false;
    }
    // 第三步：检查所有参数类型是否完全匹配（顺序、类型均一致）
    else {
        return std::is_same_v<args_tuple_t<Foo>, std::tuple<Args...>>;
    }
}

// 测试代码
#include <iostream>

void foo(int, double = 56) {}

int main() {
    std::cout << sigmatch<decltype(foo), void, int, double>() << '\n'; // 输出1（TRUE）
    std::cout << sigmatch<decltype(foo), void, int>() << '\n';         // 输出0（FALSE，参数数量不匹配）
    std::cout << sigmatch<decltype(foo), void, double, int>() << '\n'; // 输出0（FALSE，参数类型顺序不匹配）
    return 0;
}

说明 #

• 该方案直接提取可调用对象的原生签名，对比时完全禁止隐式转换，仅接受与函数定义完全一致的参数类型、数量及返回值。
• 支持普通函数、函数指针、成员函数指针、lambda（含捕获）等多种可调用对象类型。
• 默认参数属于调用期语法糖，不会被计入函数签名，因此仅传int时因参数数量不匹配返回false，符合预期。

C++20+ 简化方案 #

利用C++20的requires表达式与概念（Concepts），可以更简洁地实现严格匹配：

#include <type_traits>
#include <utility>

// 定义严格签名匹配的概念
template<typename F, typename Ret, typename... Args>
concept strict_signature_match = requires(F f, Args... args) {
    // 要求调用表达式的返回值与Ret完全相同，且参数无需隐式转换即可调用
    { std::forward<F>(f)(std::forward<Args>(args)...) } -> std::same_as<Ret>;
};

// 核心匹配函数
template <class Foo, class Ret, class... Args>
static constexpr auto sigmatch() {
    return strict_signature_match<Foo, Ret, Args...>;
}

// 测试代码
#include <iostream>

void foo(int, double = 56) {}

int main() {
    std::cout << sigmatch<decltype(foo), void, int, double>() << '\n'; // 1
    std::cout << sigmatch<decltype(foo), void, int>() << '\n';         // 0
    std::cout << sigmatch<decltype(foo), void, double, int>() << '\n'; // 0
    return 0;
}

说明 #

• requires表达式会检查传入的参数能否无隐式转换地调用目标对象，同时验证返回值类型与Ret完全一致，天然实现严格匹配。
• 代码更简洁，可读性更强，且对所有可调用对象的支持更全面。

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