Obtener parámetro lambda tipo

Question

Me gustaría obtener el primer tipo de parámetro de una función lambda, ¿es posible?

p. Ej.

en lugar de:

template<typename T> 
struct base 
{ 
    virtual bool operator()(T) = 0; 
} 

template<typename F, typename T> 
struct filter : public base<T> 
{ 
    virtual bool operator()(T) override {return /*...*/ } 
}; 

template<typename T, typename F> 
filter<T> make_filter(F func) 
{ 
     return filter<F, T>(std::move(func)); 
} 

auto f = make_filter<int>([](int n){return n % 2 == 0;}); 

me gusta:

template<typename F> 
struct filter : public base<typename param1<F>::type> 
{ 
    bool operator()(typename param1<F>::type){return /*...*/ } 
}; 

template<typename F> 
filter<F> make_filter(F func) 
{ 
     return filter<F>(std::move(func)); 
} 

auto f = make_filter([](int n){return n % 2 == 0;}); 

Sobre la base de la respuesta de Xeo esto es lo que tengo trabajando en VS2010:

template<typename FPtr> 
struct arg1_traits_impl; 

template<typename R, typename C, typename A1> 
struct arg1_traits_impl<R (C::*)(A1)>{typedef A1 arg1_type;}; 

template<typename R, typename C, typename A1> 
struct arg1_traits_impl<R (C::*)(A1) const>{typedef A1 arg1_type;}; 

template<typename T> 
typename arg1_traits_impl<T>::arg1_type arg1_type_helper(T); 

template<typename F> 
struct filter : public base<typename std::decay<decltype(detail::arg1_type_helper(&F::operator()))>::type> 
{ 
    bool operator()(typename std::decay<decltype(detail::arg1_type_helper(&F::operator()))>::type){return /*...*/ } 
}; 

template<typename T, typename F> 
filter<F> make_filter(F func) 
{ 
     return filter<F>(std::move(func)); 
} 

He intentado simplificar el código, pero cualquier intento parece romperlo.

Answer 1

La opción más fácil sería simplemente hacer que el operator() una plantilla en sí:

template<typename F> 
struct filter 
{ 
    template<class Arg> 
    void operator(Arg&& arg){ 
     // use std::forward<Arg>(arg) to call the stored function 
    } 
}; 

template<typename F> 
filter<F> make_filter(F func) 
{ 
     return filter<F>(std::move(func)); 
} 

auto f = make_filter([](int n){return n % 2 == 0;}); 

---

Ahora, teóricamente, el siguiente código debe trabajar sólo . Sin embargo, no lo hace con MSVC10 gracias a un error:

#include <iostream> 
#include <typeinfo> 

template<class FPtr> 
struct function_traits; 

template<class T, class C> 
struct function_traits<T (C::*)> 
{ 
    typedef T type; 
}; 

template<class F> 
void bar(F f){ 
    typedef typename function_traits< 
     decltype(&F::operator())>::type signature; 
    std::cout << typeid(signature).name(); 
} 

int main(){ 
    bar([](int n){ return n % 2 == 0; }); 
} 

Here 's un ejemplo de cómo se vería con GCC. MSVC10, sin embargo, simplemente no compila el código. Vea this question of mine para más detalles. Básicamente, MSVC10 no trata decltype(&F::operator()) como un tipo dependiente. Aquí hay una solución alternativa que se ideó en un chat discussion:

#include <iostream> 
#include <typeinfo> 
#include <type_traits> 

template<class FPtr> 
struct function_traits; 

template<class R, class C, class A1> 
struct function_traits<R (C::*)(A1)> 
{ // non-const specialization 
    typedef A1 arg_type; 
    typedef R result_type; 
    typedef R type(A1); 
}; 

template<class R, class C, class A1> 
struct function_traits<R (C::*)(A1) const> 
{ // const specialization 
    typedef A1 arg_type; 
    typedef R result_type; 
    typedef R type(A1); 
}; 

template<class T> 
typename function_traits<T>::type* bar_helper(T); 

template<class F> 
void bar(F f){ 
    typedef decltype(bar_helper(&F::operator())) fptr; 
    typedef typename std::remove_pointer<fptr>::type signature; 
    std::cout << typeid(signature).name(); 
} 

int main(){ 
    bar([](int n){ return n % 2 == 0; }); 
}