Question

拥有以下代码：

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<
           ^

我会收到以下错误：

std::enable_if

当我注释掉array_push($response['books'], $book);模板参数时，它会编译并运行得很好。为什么呢？

Answer 1

来自cppreference：

检查T是否为函数类型。类似std::function，lambdas，带有重载operator（）的类和指向函数的指针都不算作函数类型。

This answer解释说您还需要使用std::remove_pointer<F>::type作为类型，因为函数在传递值时会转换为指向函数的指针。所以你的代码应该是这样的：

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

Answer 2

解决此问题的另一种方法是编写更具体的类型特征。例如，这一个检查参数类型是否可转换，并适用于任何可调用的。

#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
}

Answer 3

看看std::is_invocable，它也涵盖了C ++ 17中的lambda（std::is_callable不存在）。

为什么std :: is_function对于简单函数和lambdas返回false？

3 个答案: