在variadic模板中从lambda隐式转换为std :: function

Question

我想实现一个以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 ?
    );

Answer 1

问题是你有一个可变参数模板，它开始尝试查看它除了你的显式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.deduct.type]）。

yield2回避了这个问题，因为它将结果类型放入非推导的上下文中，但由于您明确指定了模板参数，因此它将仅使用那些显式指定的参数（ char ）来推断类型（＃1的工作原理基本相同）。

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

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

另一个解决方法是static_cast你的调用yield正确的类型:(我真的只是阅读[tempddeduct.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）