Testowanie, czy funkcja członkowska istnieje przy użyciu variadics

Question

Więc jestem bardzo zaznajomiony z paradygmatem testowania, jeśli istnieje funkcja członka. Obecnie ten kod działa:

#include <iostream> 
#include <type_traits> 

struct has_mem_func_foo_impl { 
    template <typename U, U> 
    struct chk { }; 

    template <typename Class, typename Arg> 
    static std::true_type has_foo(chk<void(Class::*)(Arg), &Class::foo>*); 

    template <typename, typename> 
    static std::false_type has_foo(...); 
}; 

template <typename Class, typename Arg> 
struct has_mem_func_foo : decltype(has_mem_func_foo_impl::template has_foo<Class,Arg>(nullptr)) { }; 


struct bar { 
    void foo(int) { } 
}; 

int main() { 
    static_assert(has_mem_func_foo<bar, int>::value, "bar has foo(int)"); 
} 

niestety jeśli zrobię lekką korektę:

#include <iostream> 
#include <type_traits> 

struct has_mem_func_foo_impl { 
    template <typename U, U> 
    struct chk { }; 

    template <typename Class, typename... Arg> 
    static std::true_type has_foo(chk<void(Class::*)(Arg...), &Class::foo>*); 

    template <typename, typename...> 
    static std::false_type has_foo(...); 
}; 

template <typename Class, typename... Arg> 
struct has_mem_func_foo : decltype(has_mem_func_foo_impl::template has_foo<Class,Arg...>(nullptr)) { }; 


struct bar { 
    void foo(int) { } 
}; 

int main() { 
    static_assert(has_mem_func_foo<bar, int>::value, "bar has foo(int)"); 
} 

mój statyczny twierdzenie zawiedzie. Miałem wrażenie, że pakiety parametrów szablonów variadic traktowane są tak samo, gdy są rozszerzane na swoje miejsca. Zarówno gcc, jak i clang dają nieudane asercje statyczne.

Prawdziwym źródłem mojego pytania jest zatem, czy to standardowe zachowanie? Zawodzi również w przypadku testowania obecności funkcji członów z szablonem variadic.

Answer 1

Problem polega na tym, że Arg... przekazanie int nie wystarczy. Byłoby ważne, aby kompilator dodawał nowe argumenty na końcu.

Dedukowanie, co dodać na końcu z nullptr_t nie jest możliwe, więc kompilator mówi "Poddaję się, a nie ten przypadek".

But we don't need to have Arg... in a deducable context for your trick to work:

#include <iostream> 
#include <type_traits> 

template<class Sig> 
struct has_mem_func_foo_impl; 

template<class R, class...Args> 
struct has_mem_func_foo_impl<R(Args...)> { 
    template <typename U, U> 
    struct chk { }; 

    template <typename Class> 
    static constexpr std::true_type has_foo(chk<R(Class::*)(Args...), &Class::foo>*) { return {}; } 

    template <typename> 
    static constexpr std::false_type has_foo(...) { return {}; } 
}; 

template <typename Class, typename Sig> 
struct has_mem_func_foo : 
    decltype(has_mem_func_foo_impl<Sig>::template has_foo<Class>(nullptr)) 
{}; 

struct bar { 
    void foo(int) { } 
}; 


int main() { 
    static_assert(has_mem_func_foo<bar, void(int)>::value, "bar has foo(int)"); 
} 

przesuwamy Args... do samej klasie, a następnie przekazać tylko w typie do funkcji. To blokuje odliczanie, co powoduje, że konwersja nullptr do wskaźnika funkcji członka jest możliwa, a rzeczy znów działają.

Wprowadziłem również poprawioną składnię opartą na sygnaturach, co oznacza również, że obsługuje ona dopasowanie typu powrotu.

Pamiętaj, że możesz zadawać niewłaściwe pytania. Pytasz, czy istnieje funkcja składowa z konkretnym sygnaturą: często chcesz wiedzieć, czy istnieje funkcja składowa, która jest możliwa do zaakceptowania z określonym zbiorem argumentów, z typem zwracanym zgodnym z twoją wartością zwracaną.

namespace details { 
    template<class T, class Sig, class=void> 
    struct has_foo:std::false_type{}; 

    template<class T, class R, class... Args> 
    struct has_foo<T, R(Args...), 
    typename std::enable_if< 
     std::is_convertible< 
     decltype(std::declval<T>().foo(std::declval<Args>()...)), 
     R 
     >::value 
     || std::is_same<R, void>::value // all return types are compatible with void 
     // and, due to SFINAE, we can invoke T.foo(Args...) (otherwise previous clause fails) 
    >::type 
    >:std::true_type{}; 
} 
template<class T, class Sig> 
using has_foo = std::integral_constant<bool, details::has_foo<T, Sig>::value>; 

który próbuje wywołać T.foo(int) i sprawdza, czy wartość zwracana jest kompatybilne.

Dla zabawy zrobiłem typ has_foo w rzeczywistości być true_type lub false_type, nie odziedziczone z. Mógłbym po prostu:

template<class T, class Sig> 
using has_foo = details::has_foo<T, Sig>; 

jeśli nie chciałem tej dodatkowej funkcji.