如何根据对象的调用签名以可调用对象作为参数来重载函数？

Question

例如，给定以下代码

class A {
 public:
    double operator()(double foo) {
        return foo;
    }
};

class B {
 public:
    double operator()(double foo, int bar) {
        return foo + bar;
    }
};

我想编写 fun 的两个版本，一个适用于具有 A 签名的对象，另一个适用于具有 B 签名的对象：

template <typename F, typename T>
T fun(F f, T t) {
    return f(t);
}

template <typename F, typename T>
T fun(F f, T t) {
    return f(t, 2);
}

我期待这种行为

A a();
B b();
fun(a, 4.0);  // I want this to be 4.0
fun(b, 4.0);  // I want this to be 6.0

当然前面的例子在编译时会抛出模板重定义错误。

如果 B 是一个函数，我可以将 fun 改写成这样：

template <typename T>
T fun(T (f)(T, int), T t) {
    return f(t, 2);
}

但我希望 fun 同时使用函数和可调用对象。使用 std::bind 或 std::function 可能会解决问题，但我使用的是 C++98，而这些是在 C++11 中引入的。

Answer 1

这是从 this question 修改而来的解决方案，以适应 void-returning 功能。解决方案很简单，就是使用 sizeof(possibly-void-expression, 1)。

#include <cstdlib>
#include <iostream>

// like std::declval in c++11
template <typename T>
T& decl_val();

// just use the type and ignore the value. 
template <std::size_t, typename T = void> 
struct ignore_value {typedef T type;};

// This is basic expression-based SFINAE.
// If the expression inside sizeof() is invalid, substitution fails.
// The expression, when valid, is always of type int, 
// thanks to the comma operator.
// The expression is valid if an F is callable with specified parameters. 
template <class F>
typename ignore_value<sizeof(decl_val<F>()(1),1), void>::type
call(F f)
{
    f(1);
}

// Same, with different parameters passed to an F.
template <class F>
typename ignore_value<sizeof(decl_val<F>()(1,1),1), void>::type
call(F f)
{
    f(1, 2);
}

void func1(int) { std::cout << "func1\n"; }
void func2(int,int) { std::cout << "func2\n"; }

struct A
{
    void operator()(int){ std::cout << "A\n"; }
};

struct B
{
    void operator()(int, int){ std::cout << "B\n"; }
};

struct C
{
    void operator()(int){ std::cout << "C1\n"; }
    void operator()(int, int){ std::cout << "C2\n"; }
};

int main()
{
    call(func1);
    call(func2);
    call(A());
    call(B());
    // call(C()); // ambiguous
}

在 c++98 模式下使用 gcc 和 clang 检查。

如何根据对象的调用签名以可调用对象作为参数来重载函数？

How can I overload a function with a callable object as a parameter based on the object's call signature?

templates

overloading

method-signature

c++98

callable-object