C++ 函数模板适用于本地lambda，但不适用于其他函数

因此，我编写了一个函数，它可以“顺序”组合void lambda，以便我可以在算法中立即使用它们：

template <typename F, typename... Fs>
auto lambdaList(F f, Fs... fs)
{
    return [=] (auto&... args) { f(args...); lambdaList(fs...)(args...); };
}

template <typename F>
auto lambdaList(F f)
{
    return [=] (auto&... args) { f(args...); };
}

---

为什么有时有效，有时无效？

您需要反转功能：

template <typename F>
auto lambdaList(F f)
{
    return [=] (auto&... args) { f(args...); };
}

template <typename F, typename... Fs>
auto lambdaList(F f, Fs... fs)
{
    return [=] (auto&... args) { f(args...); lambdaList(fs...)(args...); };
}

现在我们不需要担心任何类型的查找。如果您可以访问支持某些C++1z功能的足够现代的编译器，则可以通过以下方式大大减少上述内容：

template <typename... Fs>
auto lambdaList(Fs... fs) { 
    return [=](auto const&... args) {
        (fs(args...), ...);
    };
}

模板
自动lambdaList（Fs…Fs）{
返回[=]（自动常量和参数）{
（fs（args…）；
};
}

---

这完全可以理解

“按原样，在递归案例中查找不会找到基本案例-它将始终调用自身。”@n.m.尝试问题中的新示例。谢谢，我没有考虑名称空间。。。你能解释一下（void）int[]{0，（void（fs（args…），0）…..在这里做什么吗？这是一种常见的模式吗？@lemko这是一种围绕扩展包表达式的困难而进行的黑客攻击，这种方式会导致它们从左到右执行。在这里，我们创建了一个int数组（全部为0）然后丢弃它，作为一种副作用，扩展一组表达式并按保证的顺序运行它们。@Lemko看一看。这可能是最好的解释。我编辑了你的示例，使其完全独立。将来，我们的好问题指导原则是提供一个。

template <typename F>
auto lambdaList(F f)
{
    return [=] (auto&... args) { f(args...); };
}

template <typename F, typename... Fs>
auto lambdaList(F f, Fs... fs)
{
    return [=] (auto&... args) { f(args...); lambdaList(fs...)(args...); };
}

template <typename... Fs>
auto lambdaList(Fs... fs) { 
    using swallow = int [];
    return [=](auto const&... args) {
        (void)swallow{0,
            (void(fs(args...)), 0)...
        };
    };
}

template <typename... Fs>
auto lambdaList(Fs... fs) { 
    return [=](auto const&... args) {
        (fs(args...), ...);
    };
}