Warum std :: is_function gibt false für einfache Funktionen und Lambdas zurück?

Question

das folgende Stück Code zu haben:

#include <iostream> 
#include <type_traits> 

template <typename F, 
      typename = typename std::enable_if< 
               std::is_function<F>::value 
              >::type> 
int fun(F f) // line 8 
{ 
    return f(3); 
} 

int l7(int x) 
{ 
    return x%7; 
} 

int main() 
{ 
    auto l = [](int x) -> int{ 
    return x%7; 
    }; 
    fun(l); // line 23 
    //fun(l7); this will also fail even though l7 is a regular function 

    std::cout << std::is_function<decltype(l7)>::value ; // prints 1 
} 

ich die folgende Fehlermeldung erhalten:

main2.cpp: In function ‘int main()’: 
main2.cpp:23:8: error: no matching function for call to ‘fun(main()::<lambda(int)>&)’ 
    fun(l); 
     ^
main2.cpp:8:5: note: candidate: template<class F, class> int fun(F) 
int fun(F f) 
    ^
main2.cpp:8:5: note: template argument deduction/substitution failed: 
main2.cpp:5:11: error: no type named ‘type’ in ‘struct std::enable_if<false, void>’ 
      typename = typename std::enable_if< 
     ^

Wenn ich die std::enable_if Template-Parameter kommentieren Sie dann kompiliert und läuft gut. Warum?

Answer 1

Von cppreference:

Checks whether T is a function type. Types like std::function , lambdas, classes with overloaded operator() and pointers to functions don't count as function types.

This answer erklärt, dass müssen Sie auch std::remove_pointer<F>::type als Typ verwenden, da Funktionen Zeiger auf Funktionen umgewandelt werden, wenn sie von Wert übergeben. Ihr Code sollte also wie folgt aussehen:

Answer 2

Eine weitere Möglichkeit, dieses Problem anzugehen, besteht darin, eine spezifischere Typeigenschaft zu schreiben. Dieser überprüft beispielsweise, ob die Argumenttypen konvertierbar sind und für alles, was aufrufbar ist, funktionieren.

#include <iostream> 
#include <type_traits> 
#include <utility> 
#include <string> 

template<class T, class...Args> 
struct is_callable 
{ 
    template<class U> static auto test(U*p) -> decltype((*p)(std::declval<Args>()...), void(), std::true_type()); 

    template<class U> static auto test(...) -> decltype(std::false_type()); 

    static constexpr auto value = decltype(test<T>(nullptr))::value; 
}; 

template<class T, class...Args> 
static constexpr auto CallableWith = is_callable<T, Args...>::value; 


template <typename F, 
std::enable_if_t< 
CallableWith<F, int> 
>* = nullptr 
> 
int fun(F f) // line 8 
{ 
    return f(3); 
} 

int l7(int x) 
{ 
    return x%7; 
} 

int main() 
{ 
    auto l = [](int x) -> int{ 
     return x%7; 
    }; 

    std::cout << "fun(l) returns " << fun(l) << std::endl; 

    std::cout << CallableWith<decltype(l7), int> << std::endl; // prints 1 
    std::cout << CallableWith<decltype(l7), float> << std::endl; // prints 1 because float converts to int 
    std::cout << CallableWith<decltype(l7), const std::string&> << std::endl; // prints 0 
}