número del argumento de un puntero de función

Question

ahora estoy utilizando este código: (. El usuario no puede llamar argc con una función con cualquier número de argumentos)

size_t argc(std::function<Foo()>) 
    { return 0; } 

    size_t argc(std::function<Foo(Bar)>) 
    { return 1; } 

    size_t argc(std::function<Foo(Bar, Bar)>) 
    { return 2; } 

    size_t argc(std::function<Foo(Bar, Bar, Bar)>) 
    { return 3; } 

    // ... 

Pero es un poco feo y limitado Hay una mejor manera de hacerlo?

Nota: el tipo de devolución y el tipo de argumento son siempre los mismos. Sé que puedo usar plantillas para aceptar cualquier tipo, pero no lo necesito.

Answer 1

Limpiador de @ respuesta de Paolo, que puedan utilizarse con objetos reales:

template<class R, class... Args> 
constexpr unsigned arity(std::function<R(Args...)> const&){ 
    return sizeof...(Args); 
} 

Answer 2

El siguiente funcionará para cualquier aridad, pero acepta tipos de argumentos arbitrarios:

template <typename T> 
struct arity 
{ 
}; 

template <typename... Args> 
struct arity<std::function<Foo(Args...)>> 
{ 
    static const int value = sizeof...(Args); 
}; 

Si realmente desea limitar el tipo de argumento que son funciones de tipo Foo(Bar, Bar, ...), entonces usted puede hacer algo como esto:

template <typename T> 
struct arity 
{ 
}; 

template <typename... Args> 
struct const_tuple 
{ 
}; 

template <> 
struct const_tuple<> 
{ 
    struct unsupported_function_type { }; 
}; 

template <typename... Args> 
struct const_tuple<Bar, Args...> 
{ 
    typedef typename const_tuple<Args...>::unsupported_function_type unsupported_function_type; 
}; 

template <typename... Args> 
struct arity<std::function<Foo(Args...)>> : public const_tuple<Args...>::unsupported_function_type 
{ 
    static const int value = sizeof...(Args); 
}; 

Esto le dará un error de compilación siempre que se invoque arity con un tipo de función incompatible. Versión