检索对象的函数操作符的参数类型

Question

我有一个包装器，它将具有多个参数的函数转换为仅具有单个参数的函数(提供了其他参数的值)。此代码与函数:

一起工作。

template <class R, class F, class A0, class A1>
class CMyWrapper {
     F m_f;
     A0 m_default_a0;
public:
     CMyWrapper(F f, const A0 &default_a0)
         :m_f(f), m_default_a0(default_a0)
     {}
     R operator ()(const A1 &a1) const
     {
         return m_f(m_default_a0, a1);
     }
};
template <class R, class A0, class A1>
CMyWrapper<R, R (*)(const A0&, const A1&), A0, A1>
    SupplyConstArg(R (*fun)(const A0&, const A1&), const A0 &default_a0)
{
    return CMyWrapper<R, R (*)(const A0&, const A1&), A0, A1>(fun, default_a0);
}
double MyFunc(const double &x, const double &y); // some function

所以现在我可以做例如SupplyConstArg(MyFunc, 1.23)(4.56)，它调用MyFunc(1.23, 4.56)(这个表达式的左边部分是一个函数对象，它提供一个常量的第一个参数)。到目前为止一切顺利。

然而，我在为函数对象而不是函数编写类似的函数时遇到了一些困难(出于性能原因，我希望尽可能避免使用函数指针)。假设:

struct CMyFunObj {
    double operator ()(const double &x, const double &y);
};

我的问题是我如何匹配返回类型或参数的类型，给定这样的函数对象的实例?到目前为止，我想到了:

template <class F, class R, class A0, class A1>
R Infer(F f, R (F::*fun)(const A0 &a0, const A1 &a1) = &F::operator ());

可以工作，但只有在第二个参数也指定的情况下，例如调用:

Infer(CMyFunObj(), &CMyFunObj::operator ());

，但如果省略第二个参数并依赖默认值则不会。在c++ 03中有什么想法吗?

Answer 1

在c++ 03中，你不能像那样推断类型(除非你想使用typeof)，所以你必须实际提供它:

struct CMyFunObj {
    typedef double result_type;
    double operator()(const double &x, const double &y);
};

现在你可以使用额外的信息:

template <class F, class A0>
CMyWrapper<typename F::result_type, F, A0>
SupplyConstArg(F f, A0 const& a0) {
    return CMyWrapper<typename F::result_type, F, A0>(f, a0);
}
SupplyConstArg(CMyFunObj(), 4.0)(5.0);

在CMyWrapper中不需要A1类型，它可以作为operator()的模板参数。

Answer 2

我不确定我是否明白你的问题，但你的意思可能是这样的?

struct X {};
struct Y {};
template <class R, class A0, class A1, class F, R(F::*)(const A0 &, const A1 &) = &F::operator()>
void Infer(F f) { }
struct S {
    void operator()(const X &, const Y &) { }
    void foo(const X &, const Y &) { }
};
int main() {
    Infer<void, X, Y>(S{});
    Infer<void, X, Y, S, &S::foo>(S{});
}

根据注释，这应该在c++ 03中工作:

struct X {};
struct Y {};
template <class R, class A0, class A1, class F>
void Infer(F f, R(F::*ptr)(const A0 &, const A1 &)) { (f.*ptr)(A0(), A1()); }
template<class F>
void Infer(F f) {
    Infer(f, &F::operator());
}
struct S {
    void operator()(const X &, const Y &) { }
    void foo(const int &, const char &) { }
};
int main() {
    Infer(S());
    Infer(S(), &S::foo);
}

这样，您可以指定要调用的方法，也可以依赖于将其作为参数显式推送的中间函数。

Answer 3

您可以简单地使用一个中间函数:

template <class F, class R, class A0, class A1>
void Infer(F f, R (F::*fun)(const A0 &a0, const A1 &a1));
template <class F>
void Infer(F f) {
    Infer(f, &F::operator());
}
Infer(CMyFunObj());

如果需要推断类型，可以按照Barry所说的做，如果不想修改函子，可以使用外部辅助类:

template <class U>
struct result_type;
template <typename F>
typename result_type<F>::type Infer(F f) {
    return Infer(f, &F::operator());
}

然后:

struct CMyFunObj {
    double operator ()(const double& x, const double& y) { return x + y; }
};
template <>
struct result_type<CMyFunObj> {
    typedef double type;
};