c++ - ¿Es posible averiguar el tipo de parámetro y el tipo de retorno de una lambda?

metaprogramming c++11

Question

Dado un lambda, ¿es posible averiguar su tipo de parámetro y tipo de retorno? Si es así, ¿cómo?

Básicamente, quiero lambda_traits que se puede usar de las siguientes maneras:

auto lambda = [](int i) { return long(i*10); };

lambda_traits<decltype(lambda)>::param_type  i; //i should be int
lambda_traits<decltype(lambda)>::return_type l; //l should be long

La motivación detrás es que quiero usar lambda_traits en una plantilla de función que acepta un lambda como argumento, y necesito saber su tipo de parámetro y el tipo de retorno dentro de la función:

template<typename TLambda>
void f(TLambda lambda)
{
   typedef typename lambda_traits<TLambda>::param_type  P;
   typedef typename lambda_traits<TLambda>::return_type R;

   std::function<R(P)> fun = lambda; //I want to do this!
   //...
}

Por el momento, podemos suponer que la lambda toma exactamente un argumento.

Inicialmente, traté de trabajar con std::function como:

template<typename T>
A<T> f(std::function<bool(T)> fun)
{
   return A<T>(fun);
}

f([](int){return true;}); //error

Pero obviamente daría error ( ideone ). Así que lo cambié a la versión TLambda de la plantilla de función y quiero construir el objeto std::function dentro de la función (como se muestra arriba).

Answer 1

Aunque no estoy seguro de que esto sea estrictamente estándar, ideone compiló el siguiente código:

template< class > struct mem_type;

template< class C, class T > struct mem_type< T C::* > {
  typedef T type;
};

template< class T > struct lambda_func_type {
  typedef typename mem_type< decltype( &T::operator() ) >::type type;
};

int main() {
  auto l = [](int i) { return long(i); };
  typedef lambda_func_type< decltype(l) >::type T;
  static_assert( std::is_same< T, long( int )const >::value, "" );
}

Sin embargo, esto proporciona solo el tipo de función, por lo que el resultado y los tipos de parámetros deben extraerse de él. Si puede usar boost::function_traits , result_type y arg1_type cumplirán con el propósito. Como ideone parece no proporcionar impulso en el modo C ++ 11, no pude publicar el código real, lo siento.

Answer 2

El método de especialización que se muestra en la respuesta de @KennyTM puede ampliarse para abarcar todos los casos, incluidas las lambdas variadas y mutables:

template <typename T>
struct closure_traits : closure_traits<decltype(&T::operator())> {};

#define REM_CTOR(...) __VA_ARGS__
#define SPEC(cv, var, is_var)                                              /
template <typename C, typename R, typename... Args>                        /
struct closure_traits<R (C::*) (Args... REM_CTOR var) cv>                  /
{                                                                          /
    using arity = std::integral_constant<std::size_t, sizeof...(Args) >;   /
    using is_variadic = std::integral_constant<bool, is_var>;              /
    using is_const    = std::is_const<int cv>;                             /
                                                                           /
    using result_type = R;                                                 /
                                                                           /
    template <std::size_t i>                                               /
    using arg = typename std::tuple_element<i, std::tuple<Args...>>::type; /
};

SPEC(const, (,...), 1)
SPEC(const, (), 0)
SPEC(, (,...), 1)
SPEC(, (), 0)

Demo

Tenga en cuenta que la aridad no se ajusta para el operator() variable operator() s. En su lugar, uno también puede considerar is_variadic .

Answer 3

Es curioso, acabo de escribir una implementación de function_traits basada en la especialización de una plantilla en una lambda en C ++ 0x que puede dar los tipos de parámetros. El truco, como se describe en la respuesta en esa pregunta, es usar el tipo decltype del operator() de lambda operator() .

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.
    };
};

// test code below:
int main()
{
    auto lambda = [](int i) { return long(i*10); };

    typedef function_traits<decltype(lambda)> traits;

    static_assert(std::is_same<long, traits::result_type>::value, "err");
    static_assert(std::is_same<int, traits::arg<0>::type>::value, "err");

    return 0;
}

Tenga en cuenta que esta solución no funciona para lambda genérico como [](auto x) {} .

Answer 4

La respuesta proporcionada por @KennyTM funciona muy bien; sin embargo, si una lambda no tiene parámetros, no se compila con el índice arg <0>. Si alguien más tenía este problema, tengo una solución simple (más simple que usar soluciones relacionadas con SFINAE, eso es).

Simplemente agregue void al final de la tupla en la estructura arg después de los tipos de argumentos variados. es decir

template <size_t i>
    struct arg
    {
        typedef typename std::tuple_element<i, std::tuple<Args...,void>>::type type;
    };

dado que la arity no depende del número real de parámetros de la plantilla, el real no será incorrecto, y si es 0, entonces al menos arg <0> seguirá existiendo y podrá hacer con él lo que desee. Si ya planea no exceder el índice arg<arity-1> entonces no debería interferir con su implementación actual.