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

Question

所以我写了一个函数来“顺序地”组成 void lambdas，这样我就可以在算法中一次使用它们：

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...); };
}

如果我使用本地 lambda，它会起作用，但当我在不同的命名空间中使用函数时就不行：

#include <iostream>

namespace foo {
    void a() { std::cout << "a\n"; }
    void b() { std::cout << "b\n"; }
}

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...); };
}

int main() {
    auto printStarBefore = [] (const std::string& str) { 
        std::cout << "* " + str; 
    };
    auto printStarAfter = [] (const std::string& str) { 
        std::cout << str + " *" << std::endl; 
    };    

    lambdaList(printStarBefore, printStarAfter)("hi");  // ok
    lambdaList(foo::a, foo::b)();                       // error
}

错误是no matching function for call to 'lambdaList()' 与：

main.cpp:11:56: note:   candidate expects at least 1 argument, 0 provided
     return [=] (auto&... args) { f(args...); lambdaList(fs...)(args...); };
                                              ~~~~~~~~~~^~~~~~~

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

Answer 1

你需要反转你的函数：

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...); };
}

按原样，您的基本情况不会通过递归案例中的不合格查找找到 - 它只能通过参数相关查找找到。如果参数与lambdaList 不在同一个命名空间中，则根本找不到它，递归步骤将始终调用自身。这就是你的错误的根源。

新的排序允许基本情况 lambdaList() 通过正常的非限定查找找到 - 现在它在递归 lambdaList() 的定义点可见。

---

也就是说，我们可以做得更好。编写一个调用一切的函数：

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

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

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

这完全可以理解！