使用模板，函数类型（和参数类型）为模板参数。

template <typename F, typename ...P>
requires std::is_invocable_r_v<F, P...> // This line is optional, it merely gives better errors if a wrong function/arguments are passed.
void wrap(F &&func, P &&... params)
{
    bool result = std::invoke(std::forward<F>(func), std::forward<P>(params)...);
}

然后：

wrap(foo1, 1):
wrap(foo2, 2, 3.4);

或者，穷人的版本。没有那么有效或灵活，但更容易理解。

template <typename F, typename ...P>
void wrap(F func, P ...params)
{
    bool result = func(params...);
}

是这样吗？：

#include <iostream>

typedef bool(*Foo1)(int);
typedef bool(*Foo2)(int, double);

bool checkFunctions(Foo1 foo1, Foo2 foo2) {
    bool foo1Result = foo1(5);
    bool foo2Result = foo2(5, 3.14);
    return foo1Result && foo2Result;
}

int main() {
    bool result = checkFunctions(foo1, foo2);
    std::cout << "Result: " << result << std::endl;
    return 0;
}

创建一个接受可调用对象的函数，然后可以使用lambda来捕获参数。

#include <type_traits>
#include <iostream>

bool condition = false;

bool foo1(int x) {

    if (condition)
        return 0;
    else
        return 1;
}

bool foo2(int x, double y) {

    if (condition)
        return 0;
    else
        return 1;
}

// the enable_if_t ensures only callables returning a bool are accepted
template<typename fn_t>
auto check(fn_t&& fn) -> std::enable_if_t<std::is_same_v<decltype(fn()), bool>, bool>
{
    bool value = fn();
    std::cout << "the return value is " << (value ? "true" : "false") << "\n";
    return value;
}

int main()
{
    int x = 1;
    check([&] { return foo1(x); });
    check([&] { return foo2(x,1.0); });

    return 0;
}

“就”放进去吧。

void foo3(bool foo1(int x), bool foo2(int x, double y)) {
      foo1(1);
      foo2(1, 1.0f);
}

一个函数的类型会被“自动地”改变为另一个函数参数列表中的函数指针，但是，（对我来说）最好明确地写上那些是指针，这意味着完全相同的代码：

void foo3(bool (*foo1)(int x), bool (*foo2)(int x, double y)) {
      foo1(1);
      foo2(1, 1.0f);
}