是否可以计算出多态 C++ 14 lambda 的参数类型和返回类型？

从这个问题开始（是否可以计算出 lambda 的参数类型和返回类型？ https://stackoverflow.com/questions/7943525/is-it-possible-to-figure-out-the-parameter-type-and-return-type-of-a-lambda）我使用了建议的function_traits很多。然而，随着 C++14 多态 lambda 的出现，它们给我带来了困难。

template <typename T>
struct function_traits
    : public function_traits<decltype(&T::operator())>
{};
// For generic types, directly use the result of the signature of its 'operator()'

template <typename ClassType, typename ReturnType, typename... Args>
struct function_traits<ReturnType(ClassType::*)(Args...) const>
// we specialize for pointers to member function
{
    enum { arity = sizeof...(Args) };
    // arity is the number of arguments.

    typedef ReturnType result_type;

    template <size_t i>
    struct arg
    {
        typedef typename std::tuple_element<i, std::tuple<Args...>>::type type;
        // the i-th argument is equivalent to the i-th tuple element of a tuple
        // composed of those arguments.
    };
};

The operator()正如其他问题的答案中所提议的，现在已超载，如标准中所述以支持：

auto lambda1 = [](auto& a) { a.foo(); } 

and

auto lambda2 = [](auto&&... args) { foo(args...); };

这种超载现在撕裂了function_traits类分开，因为编译器无法解析正确的版本operator().

lambda.cpp:98:38: error: reference to overloaded function could not be
      resolved; did you mean to call it?
      typedef function_traits<decltype(&T::operator())> caller;

是否有可能以某种方式实现的功能function_traits关于 C++14 的多态 lambda？

目前，这在一般意义上是不可能做到的，但如果您的 lambda 的所有参数都具有 auto 功能，并且可以将所有参数替换为某种已知类型，那么您可以修改此问题的答案：C++ 元函数来确定类型是否可调用 https://stackoverflow.com/questions/5100015/c-metafunction-to-determine-whether-a-type-is-callable

沿着

static const bool OneArg = (sizeof( test<T, int>(0)  ) == 1);
static const bool TwoArg = (sizeof( test<T, int, int>(0)  ) == 1);
static const bool ThreeArg = (sizeof( test<T, int, int, int>(0)  ) == 1);
static constexpr std::size_t TemplatedOperatorArgSize = 
    OneArg
        ? 1
        : TwoArg
            ? 2
            : ThreeArg
                ? 3
                : -1;

对嵌套三元组表示歉意。然后使用类似这样的东西来调用它：

template<size_t N, typename T>
struct Apply {
    template<typename F, typename... A>
    static inline decltype(auto) apply(F && f, A &&... a) {
        return Apply<N-1, T>::apply(::std::forward<F>(f), std::declval<T>(), ::std::forward<A>(a)...);
    }
};

template<typename T>
struct Apply<0, T> {
    template<typename F, typename... A>
    static inline decltype(auto) apply(F && f, A &&... a) {
        return invoke(std::forward<F>(f), std::forward<A>(a)...);
    }
};

template<std::size_t Size, typename T, typename F>
inline decltype(auto) apply(F && f) {
    return Apply<Size, T>::apply(::std::forward<F>(f));
}

使用调用来自：http://en.cppreference.com/w/cpp/utility/function/invoke http://en.cppreference.com/w/cpp/utility/functional/invoke

获取返回类型

using return_type = decltype(
    apply<has_callable_operator<T>::TemplatedOperatorArgSize, int>(function)
);

第一部分可以重写以处理任意数量的参数，使用std::make_index_sequence

但总的来说，我会说你正在掉进兔子洞。祝你好运。

注意：没有测试应用代码，但它应该足以让您继续使用。

编辑：此外，返回类型需要独立于参数类型才能实现您想要的