variadic模板内从lambda到std::函数的隐式转换

implicit convert from lambda to std::function inside variadic template

本文关键字：函数 转换 std lambda variadic      更新时间：2023-10-16

我想实现一个以lambda为参数的模板函数。

#include <functional>
template<typename ... Result> using Fun = std::function<void(Result ...)>;
template<typename ... Result> void yield(Fun<Result ...>&& body) {};
template <typename T>
struct identity {
typedef T type;
};
template<typename ... Result> void yield2(typename identity<Fun<Result ...>>::type && body) {};
int main() {
yield<char>(
Fun<char>(
[](char) -> void {} // 1. success
)
);
yield2<char>(
[](char) -> void {} // 2. success with identify
);
yield<char>(
[](char) -> void {} // 3. fail, seems achievable
);
yield(
[](char) -> void {} // 4. fail, impossible ?
);
return 0;
}

为什么情况3失败？我已经给模板提供了模板参数，所以它应该能够推导出函数类型，并将lambda隐式转换为函数

编辑：

编译器总是从函数参数中减少模板参数，我们能反过来吗？

yield<char>(
[](auto&& c) -> void {} // 5. is it possible ?
);

问题是，您有一个可变模板，它开始尝试查看除了显式char参数之外，它还可以推断出"什么"。

如果你有一个这样的单一参数模板：

template<typename Result> using Fun = std::function<void(Result)>;
template<typename Result> void yield(Fun<Result>&& body) {};

你会注意到

yield<char>(
[](char) -> void {} // 3. fail, seems achievable
);

完全没有问题，因为std::function的整体是可推导的。

但一旦我们制作了一个可变模板，我们的编译器就会不高兴：

template<class... Result> using Fun = std::function<void(Result...)>;
template<class... Result> void yield(Fun<Result...>&& body) {};

这是因为，不管你喜不喜欢，编译器将尝试为Fun<Result...>推导出更多的模板参数，给定传入的值([temp.execure.type])。

yield2回避了这个问题，因为它将生成的类型放置在非推导的上下文中，但由于您显式指定了模板参数，它将只使用那些显式指定的参数(char)来推导类型(#1的作用原理基本相同)。

我认为最好的解决方法是yield2尝试，但您也可以这样做，以防止传递的值参与类型推导：

auto fn = &yield<char>;
fn(
[](char) -> void {}
);

另一种解决方法是将您对yield的调用static_cast转换为正确的类型：(实际上，我只是在阅读"非推导上下文是："下的其他可能的解决方案，用于[temp.dexeract.type])

using fn_type = void(*)(Fun<char>&&);
static_cast<fn_type>(&yield)(
[](char) -> void {}
);

编辑：最后，您可以编写一些额外的样板模板，使调用看起来更好(接近您的#4)。请记住，这是一个不完整的impl，例如：

此模板的目标是检测lambda的operator()函数并提取其返回类型和参数，以便在调用yield时可以显式指定Fun类型(提取返回类型是不必要的，因为您只使用过void)：

首先是一个帮助结构，它将允许我们检测不可变lambda的返回类型和参数类型：

template<class T>
struct Fun_Type;
template<class C, class Ret, class... Args>
struct Fun_Type<Ret(C::*)(Args...) const>
{
using type = Fun<Args...>;
};

第二，我们的助手函数call_yield，它将Fun_Type<...>::type传递给对yield:的调用

template<class ImmutableLambda>
void call_yield(ImmutableLambda&& c)
{
using Fun_t = typename Fun_Type<decltype(&ImmutableLambda::operator())>::type;
yield(Fun_t{std::forward<ImmutableLambda>(c)});
}

现在我们可以简单地称之为：

int main() {
call_yield(
[](char) -> void {}
);
}

演示(C++11)

相关文章：