如何确定以该类型为参数的函子的返回类型？

Question

假设我必须遵循以下功能：

template <typename Op, typename T> T foo(Op op) { }

Op假设有如下方法：

T Op::operator()(T&);

（这是一个简单的案例；实际上它可能有更多参数，但我知道它们的类型）。

现在，我想为T 参数设置一个默认值。问题是，为了虚假调用它（例如std::result_of<Op::operator()(int&)>，我需要有参数的类型——这正是我所缺少的类型。

是否可以从Op 中确定T？例如，我可以调用：

foo( [](int& x){ return x++; } );

我对 C++11 解决方案感兴趣；如果您需要更高标准版本的功能，那也很有趣（尤其是解释为什么会这样）。

注意：如果Op 我自己有多个兼容的 operator()'s taking references to different types, I'm ok with having to specifyT`，当然 - 但是当我这样做时编译应该会通过。

Answer 1

如果函数对象有正好一个签名，您可以通过decltype(&T::operator())发现该签名并从中推断：

template<class T> struct X : X<decltype(&T::operator())> {}; // #1
template<class T> struct X<T(T&) const> { using type = T; }; // #2
template<class C, class M> struct X<M (C::*)> : X<M> {}; // #3
// add more specializations for mutable lambdas etc. - see example

template <typename Op, typename T = typename X<Op>::type>
T foo(Op op) { /* ... */ }

Example (C++11).

---

这是一系列类型转换，表示为部分模板特化。从匿名类型 <lambda> 的 lambda 中，我们在 #1 处提取其函数调用运算符类型，给出一个成员函数指针类型，例如 int (<lambda>::*)(int&) const，它与 #3 匹配，允许我们丢弃类类型，给出 abominable函数类型int(int&) const，匹配#2，允许我们提取参数和返回类型，暴露为X::type，通过继承对X的原始实例可见。将同一模板的部分特化用于不同类型的计算是一种code-golf 技巧，您可能希望在生产代码中避免它（并使用更具表现力的名称）。

---

另一方面，如果函数对象有多个签名（模板参数、默认参数、overloaded、手工制作的函数对象等），那么这将不起作用；你需要等待更强的反思形式才能进入语言。

Answer 2

模板函数的存在说明这个问题一般是不可能回答的：

struct post_increment
{
    template<typename T>
    T operator()(T& t) const
    {
        return t++;
    }
};

foo(post_increment{});
// or in C++14: foo([](auto& t) { return t++; });

函数foo 将T& 映射到T 的某些类型集T 的结果本身就是多态的。在某些情况下，这甚至可以在 C++11 中表达：

template<typename Op>
struct foo_result_t
{
    template<typename T>
    operator T() const
    {
        T t {};
        op(t);
        return t;
    }

    Op op;
};

template <typename Op>
foo_result_t<Op> foo(Op op)
{
     return {op};
}

int i = foo(post_increment{}); // use it with an int

Answer 3

在只有一个签名的情况下的另一种解决方案。

另一个...嗯...几乎相同的ecatmur的解决方案，但基于模板函数，来推断类型，而不是模板类。

你所需要的只是一个声明函数两个声明的函数来推断类型（并返回与operator()相同的返回类型；你还可以开发另一个函数来返回，例如@ 987654323@，如果需要提取Args...类型）

template <typename T, typename R, typename ... Args>
R deducer (R(T::*)(Args...) const);

template <typename T, typename R, typename ... Args>
R deducer (R(T::*)(Args...));

和一个using（有点decltype() 谵妄）来提取R 类型

template <typename T>
using RetType = decltype(deducer(std::declval<decltype(&T::operator())>()));

以下是完整的 C++11 示例

#include <utility>

struct A
 {
   long operator() (int, char, short)
    { return 0l; }
 };

template <typename T, typename R, typename ... Args>
R deducer (R(T::*)(Args...) const);

template <typename T, typename R, typename ... Args>
R deducer (R(T::*)(Args...));

template <typename T>
using RetType = decltype(deducer(std::declval<decltype(&T::operator())>()));

int main ()
 {
   auto f = [](int& x) { return x++; };

   static_assert( std::is_same<RetType<A>, long>::value, "!" );
   static_assert( std::is_same<RetType<decltype(f)>, int>::value, "!" );
 }

如果您不想同时管理 volatile 运算符，则必须添加其他两个 deducer()

template <typename T, typename R, typename ... Args>
R deducer (R(T::*)(Args...) volatile const);

template <typename T, typename R, typename ... Args>
R deducer (R(T::*)(Args...) volatile);