传递lambda作为模板参数：实际推导出什么类型？

Question

如果我将lambda作为模板参数传递，那么推导出的参数的实际类型是什么？我查看了VS2017调试器和这个lambda的类型：[](int x) {return x; }是filename::__I2::int<lambda>(int)。

我问这个的原因是因为我想传递一个lambda，然后从中创建一个内部std::function。请注意，这与this answer有关，为什么我们必须使用CTAD来构建内部std::function，而不是仅仅将模板参数传递给std::function。

举个例子，我想做类似以下的事情：

template<class Func, class... Args> 
void createStdFunc(Func f, Args... args) {
    std::function<Func> internalFunc = f; //this does not work
}

//usage
createStdFunc([](int x) {return x; }, 5);

但是，这不起作用，我得到错误'initialising' cannot convert from 'Func' to 'std::function<Func>'。我不确定这些类型是如何不同的，以及它们如何从进入函数变为初始化std::function。请注意，我知道你可以从2017年开始使用CTAD，但是想知道2014年以及之前的解决方案是什么？

Answer 1

在C ++ 14中，您可以使用返回类型推导来计算函数签名，这意味着传递给createStdFunc的参数类型匹配：

template<class Func, class... Args> 
void createStdFunc(Func f, Args... args) {
    std::function<std::result_of_t<Func(Args...)> (Args...)> internalFunc{f}; //this does work
}

Answer 2

我的方式

#include <iostream>
#include <functional>

template <typename R, typename T, typename ... As>
constexpr std::function<R(As...)> getFuncType (R(T::*)(As...) const);

template <typename F, typename ... As>
void createStdFunc (F const & f, As ... as)
 {
   decltype(getFuncType(&F::operator()))  internalFunc { f };

   internalFunc(as...);
 }

int main ()
 {
   createStdFunc([](int x) { std::cout << x << std::endl; }, 5);
 }

也许也通过using

template <typename F>
using funcType = decltype(getFuncType(&F::operator()));

template <typename F, typename ... As>
void createStdFunc (F const & f, As ... as)
 {
   funcType<F> internalFunc { f };

   internalFunc(as...);
 }

Answer 3

代码中的问题是Func不是函数类型。这是lambda的类型。 Lambdas编译成这样的东西：

// equivalent:
// auto my_lambda = [](int v){ return v; };

struct /* unnamed */ {
    auto operator()(int v) const { return v; }
} my_lambda;

解决方案是从闭包类型中提取operator()的类型：

using my_lambda_t = decltype(my_lambda);

// type: int(my_lambda_t::*)(int) const; 
auto call_operator = &decltype(my_lambda_t)::operator();

然后，从operator()的类型，您可以推断出参数的类型和返回类型：

template<typename>
struct extract_types {};

template<typename R, typename C, typename... Args>
struct extract_types<R(C::*)(Args...) const> {
    using result = R;
    using args_types = std::tuple<Args...>;
};

此模式的通用版本在Boost.CallableTraits中提供

Answer 4

您可以编写一个简单的特征来概括可调用类型。如果你使用operator()（const和非const）处理函数指针和任何东西，你应该能够涵盖大多数用例。

#include <tuple>

// For callable types
template<class T>
struct func_type : func_type<decltype(&T::operator())>{};

// For callable types' member functions (including `operator()`)
template<class T, class R, class ... Args >
struct func_type<R (T::*)(Args...) const> : func_type<R(*)(Args...)> {};

// For function pointers
template<class R, class ... Args >
struct func_type<R (*)(Args...)> {
    using type = R(Args...);
    using result = R;
    using args = std::tuple<Args...>;
};

template<class T>
using func_type_t = typename func_type<T>::type;

然后，func_type_t<T>应该为大多数可调用类型T提供一个函数类型。示例用途：

#include <functional>

template<class Func, class... Args>
void createStdFunc(Func f, Args... args) {
    // Replaced `Func` with `func_type_t<Func>`
    std::function<func_type_t<Func>> internalFunc = f;
}

int foo(int x) { return x; }

struct bar {
    int operator()(int x) { return x; };
};


int main()
{
    // With lambda expression
    createStdFunc([](int x) {return x; }, 5);

    // With function pointer
    createStdFunc(foo, 5);

    // With std::function
    std::function<int(int)> std_func = [](int x) {return x; };
    createStdFunc(std_func, 5);

    // With a functor
    createStdFunc(bar{}, 5);
}

Answer 5

std::function模板期望它的参数是一个函数类型，它从中推断出可调用包的返回和参数类型。 lambda表达式的闭包类型是可调用的，但它不是函数类型。

C ++ 17为deduction guides引入了std::function，它允许从任何可调用的参数中推导出正确的类型。在C ++ 17之前，您可以使用一组辅助模板来推断出正确的类型，例如：

template <typename F>
struct deduce_func_type_helper;

template <typename R, typename... Args>
struct deduce_func_type_helper<R(&)(Args...)>
{
    using type = std::function<R(Args...)>;
};

template <typename R, typename... Args>
struct deduce_func_type_helper<R(*)(Args...)> : deduce_func_type_helper<R(&)(Args...)> {};

template <typename C, typename R, typename... Args>
struct deduce_func_type_helper<R(C::*)(Args...)> : deduce_func_type_helper<R(&)(Args...)> {};

template <typename C, typename R, typename... Args>
struct deduce_func_type_helper<R(C::*)(Args...) const> : deduce_func_type_helper<R(&)(Args...)> {};

template <typename C, typename R, typename... Args>
struct deduce_func_type_helper<R(C::*)(Args...) volatile> : deduce_func_type_helper<R(&)(Args...)> {};

template <typename F>
struct deduce_func_type_helper<F&> : deduce_func_type_helper<std::remove_cv_t<F>> {};

template <typename F>
struct deduce_func_type_helper<F&&> : deduce_func_type_helper<std::remove_cv_t<F>> {};

template <typename F>
struct deduce_func_type_helper : deduce_func_type_helper<decltype(&F::operator())> {};

template <typename F>
using func_type_t = typename deduce_func_type_helper<F>::type;

live example here

注意上面的例子并不完整;它缺少一些特殊化，例如，const，volatile和不同的ref限定符的所有可能组合。所以这可能会变得非常冗长，如果可以的话，你可能会想要使用C ++ 17 ...