没有与 lambdas 匹配的函数 std::forward

Question

考虑以下代码，灵感来自 Barry 对this 问题的回答：

// Include
#include <tuple>
#include <utility>
#include <iostream>
#include <type_traits>

// Generic overload rank
template <std::size_t N> 
struct overload_rank 
: overload_rank<N - 1> 
{
};

// Default overload rank
template <> 
struct overload_rank<0> 
{
};

// Prepend argument to function
template <std::size_t N, class F>
auto prepend_overload_rank(F&& f) {
    using rank = overload_rank<N>;
    return [f = std::forward<F>(f)](rank, auto&&... args) -> decltype(auto) {
        return std::forward<F>(f)(std::forward<decltype(args)>(args)...); // here
    };
}

// Main
int main(int argc, char* argv[])
{
    auto f = [](int i){return i;};
    prepend_overload_rank<5>(f)(overload_rank<5>(), 1);
    return 0;
}

由于注释here 的行没有编译，我不明白为什么：

With g++:
error: no matching function for call to 'forward<main(int, char**)::<lambda(int)>&>(const main(int, char**)::<lambda(int)>&)'
With clang:
error: no matching function for call to 'forward'

替换

return std::forward<F>(f)(std::forward<decltype(args)>(args)...); 

通过

return f(std::forward<decltype(args)>(args)...); 

显然让它工作了，但是我还是不明白为什么，我的目标是实现功能的完美转发。

Answer 1

当mutable 说明符不存在时，显然编译器要么存在错误，要么允许将复制捕获的变量声明为const。
具有讽刺意味的是，以下代码可以使用 GCC 编译，但不能使用 clang：

#include <type_traits>

int main(int argc, char* argv[]) {
    int i = 0;
    [j = i](){ static_assert(std::is_same<decltype(j), const int>::value, "!"); }();
}

要解决这两种情况下的问题，您可以这样做：

return [f = std::forward<F>(f)](auto&&... args) -> decltype(auto) {
    return std::forward<decltype(f)>(f)(std::forward<decltype(args)>(args)...); // here
};

也就是说，您可以省略 mutable 关键字，但您必须在 lambda 中使用 f 副本的实际类型。请注意，原始 f 是对 lambda 函数的非常量引用，因此 F 可以不同于 lambda 中的类型 decltype(f)。
这在任何情况下都是有效的，即使对于mutable lambda。举个例子：

#include <type_traits>
#include<utility>

struct S {};

template<typename T>
void f(T &&t) {
    [t = std::forward<T>(t)]()mutable{ static_assert(std::is_same<decltype(t), S>::value, "!"); }();
    // the following doesn't compile for T is S& that isn't the type of t within the lambda
    //[t = std::forward<T>(t)]()mutable{ static_assert(std::is_same<decltype(t), T>::value, "!"); }();
}

int main() {
    S s;
    f(s);
}

通常，您应该使用捕获变量的实际类型，而不是周围上下文中给出的类型。
在特定情况下，即使编译器错误地将捕获的变量声明为const，只要f 的函数运算符为const（即您的情况，对于f 是main 也不是mutable。

让你的 sn-p 工作的另一种方法是这样（如问题的 cmets 中所建议的）：

return [f = std::forward<F>(f)](auto&&... args) mutable -> decltype(auto) {
    return std::forward<F>(f)(std::forward<decltype(args)>(args)...); // here
};

在这种情况下，复制捕获的变量不能强制为const，并且类型是预期的。
无论如何，即使您打算使用 mutable 说明符，我还是建议您采纳上述建议。

---

注意。
正如this question 中所讨论的，问题是由于 GCC 的错误而出现的。使用decltype(f) 的建议仍然有效。它还解决了其他类型的问题并适用于特定情况。此外，如果错误被修复，代码将继续正常工作。