如何检查两个函数签名是否同类型？代码编译失败求助

问题背景 #

需要检查两个函数签名是否属于同一类型，编写的C++代码无法通过编译，代码及错误信息如下：

原代码 #

#include <iostream>
#include <type_traits>
#include <functional>

struct Employee {
    int id;
    int age;

    Employee(const int id, const int age) {
        this->id = id;
        this->age = age;
    }

    void print() const {
        std::cout << "ID: " << id << ", AGE: " << age << std::endl;
    }
};

template<typename T, typename Comp>
const T& get_min_emp(const T& a, const T& b, Comp comp) {
    static_assert(std::is_same<Comp, bool(*)(const T&, const T&)>::value, "invalid comparator");
    return comp(a, b) ? a : b;
}

int main() {
    Employee employee1(23, 674);
    Employee employee2(234789, 1398);

    const auto& emp = get_min_emp(employee1, employee2, [] (const Employee& emp1, const Employee& emp2) -> bool {
        return emp1.id < emp2.id;
    });
    emp.print();
}

编译错误信息 #

<source>: 在实例化 'const T& get_min_emp(const T&, const T&, Comp) [with T = Employee; Comp = main()::<lambda(const Employee&, const Employee&)>]' 时：
<source>:29:34:   由此处调用触发
<source>:21:68: 错误：static assertion failed：无效的比较器
   21 |     static_assert(std::is_same<Comp, bool(*)(const T&, const T&)>::value, "invalid comparator");
      |                                                                    ^~~~~
<source>:21:68: 备注：'std::integral_constant<bool, false>::value' 的值为 false

错误原因 #

lambda表达式是编译器生成的匿名闭包类型，和普通函数指针bool(*)(const T&, const T&)并非同一类型。即便无捕获lambda可以隐式转换为对应函数指针，std::is_same要求类型完全匹配，因此断言失败。

解决方法 #

方法1：检查可调用对象的签名兼容性（推荐） #

使用std::is_invocable_r检查传入的可调用对象是否能接受两个const T&参数，并返回bool类型。这种方式支持所有符合签名的可调用对象（lambda、仿函数、函数指针等），灵活性更高。

修改static_assert为：

static_assert(std::is_invocable_r_v<bool, Comp, const T&, const T&>, "invalid comparator");

方法2：强制lambda转换为函数指针 #

如果确实需要限制参数为函数指针类型，可以通过+前缀或显式类型转换，将无捕获lambda转换为对应函数指针：

// 使用+前缀触发隐式转换
const auto& emp = get_min_emp(employee1, employee2, +[] (const Employee& emp1, const Employee& emp2) -> bool {
    return emp1.id < emp2.id;
});

// 或者显式转换
const auto& emp = get_min_emp(employee1, employee2, 
    static_cast<bool(*)(const Employee&, const Employee&)>([] (const Employee& emp1, const Employee& emp2) -> bool {
        return emp1.id < emp2.id;
    })
);

方法3：用std::function统一类型 #

将Comp参数改为std::function<bool(const T&, const T&)，这样可以接受任何符合签名的可调用对象，同时也能通过std::is_same检查类型。但这种方式会带来轻微的类型擦除性能开销：

template<typename T>
const T& get_min_emp(const T& a, const T& b, std::function<bool(const T&, const T&)> comp) {
    static_assert(std::is_same_v<decltype(comp), std::function<bool(const T&, const T&)>>, "invalid comparator");
    return comp(a, b) ? a : b;
}

完整修复代码（方法1） #

#include <iostream>
#include <type_traits>
#include <functional>

struct Employee {
    int id;
    int age;

    // 改用初始化列表更简洁
    Employee(const int id, const int age) : id(id), age(age) {}

    void print() const {
        std::cout << "ID: " << id << ", AGE: " << age << std::endl;
    }
};

template<typename T, typename Comp>
const T& get_min_emp(const T& a, const T& b, Comp comp) {
    static_assert(std::is_invocable_r_v<bool, Comp, const T&, const T&>, "invalid comparator");
    return comp(a, b) ? a : b;
}

int main() {
    Employee employee1(23, 674);
    Employee employee2(234789, 1398);

    const auto& emp = get_min_emp(employee1, employee2, [] (const Employee& emp1, const Employee& emp2) -> bool {
        return emp1.id < emp2.id;
    });
    emp.print();
}

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