Jak mogę znaleźć liczbę argumentów funkcji szablonu?

Question

Mam następujący typ cechę:

template <class T> 
struct Arity : Arity<decltype(&T::operator())> {}; 

template <class T, class R, class... Args> 
struct Arity<R(T::*)(Args...)> { 
    static constexpr auto value = sizeof...(Args); 
}; 

template <class T, class R, class... Args> 
struct Arity<R(T::*)(Args...) const> { 
    static constexpr auto value = sizeof...(Args); 
}; 

template <class R, class... Args> 
struct Arity<R(*)(Args...)> { 
    static constexpr auto value = sizeof...(Args); 
}; 

który działa wspaniale jest znaleźć liczbę argumentów funkcji potrzebny większości przypadków użycia, ale to nie dla jednej wspólnej sprawy:

auto l1 = [](int, double){}; 
Arity<decltype(l1)>::value; // works, 2 

auto l2 = [](auto, auto){}; 
Arity<decltype(l2)>::value; // error: Reference to overloaded function could not be resolved; did you mean to call it? 

wierzę nie da się na ogół wykonać tej pracy dla dowolnej funkcji/operatora(), ponieważ w zależności od typów/wartości przekazywanych jako typy szablonów, można wybrać inne przeciążenie, lub może w ogóle nie być dostępne przeciążenie. Ponadto, nie ma sposobu, aby wiedzieć, jakie poprawne typy i wartości przekazać jako argumenty szablonu. Ale nadal, chcę, żeby to działało dla wspólnego przypadku argumentów lambda pobierających auto. Czy jest jakiś sposób, aby uczynić to bardziej niezawodnym i obejmować lambdy, które biorą auto argumenty?

Answer 1

Podejrzewam, że osiągnąłem tutaj połowę rozwiązania. Działa tylko do określonej liczby parametrów, ale w przypadku większości aplikacji nie powinno to stanowić problemu. Co więcej, jest to prawdopodobnie wysoce uproszczone, ale mój mózg nie jest teraz podstępnym SFINAE.

template < 
    class, std::size_t N, 
    class = std::make_index_sequence<N>, 
    class = void_t<> 
> 
struct CanCall : std::false_type { }; 

template <class F, std::size_t N, std::size_t... Idx> 
struct CanCall< 
    F, N, 
    std::index_sequence<Idx...>, 
    void_t<decltype(std::declval<F>()((Idx, std::declval<Any const&&>())...))> 
> : std::true_type { }; 

CanCall<F, N> powróci czy F jest wywoływalny z N parametrów dowolnego typu. Typ pomocnika Any ma niewymienionych operatorów konwersji, które umożliwiają przekształcenie go w dowolny pożądany typ parametru.

template <class F, std::size_t N = 0u, class = void> 
struct Arity : Arity<F, N + 1u, void> { }; 

template <class F, std::size_t N> 
struct Arity<F, N, std::enable_if_t<CanCall<F, N>::value>> 
: std::integral_constant<std::size_t, N> { }; 

template <class F> 
struct Arity<F, MAX_ARITY_PROBING, void> 
: std::integral_constant<std::size_t, ARITY_VARIADIC> { }; 

Arity<F> tylko sprawdza, czy F można nazwać z zero, jeden, dwa ... parametrów. Pierwsze pozytywne czekanie wygrywa. Jeśli osiągniemy parametry MAX_ARITY_PROBING, to wygaśnie Arity i przypuszcza, że ​​funkcja jest albo wariantowa, albo w ogóle nie jest funkcją.

See it live on Coliru

Answer 2

Nie sądzę, że można użyć funkcji lambda w przypadku użycia, którego typem argumentów jest auto. Funkcje takich funkcji lambda są najprawdopodobniej zaimplementowane za pomocą szablonów funkcji.

Stąd decltype nie może być stosowany z:

auto l2 = [](auto, auto){}; 
Arity<decltype(l2)>::value; 

this answer to another SO question Zobacz więcej na ten temat.