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

Question

考虑下面的代码，这些代码是受Barry对这个问题的回答启发而来的：

// 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

显然，编译器要么存在缺陷，要么允许在说明符不存在const时声明由复制捕获的变量。 讽刺的是，下面的代码可以用 GCC 编译，但不能用 clang 编译：mutable

#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关键字，但必须使用flambda 中的副本的实际类型。请注意，原始值 f是对 lambda 函数的非常量引用，因此可能与lambda 中的F类型不同。 这在任何情况下都是有效的，即使对于lambda 也是如此。举个例子：decltype(f)
mutable

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

一般来说，您应该使用捕获变量的实际类型，而不是周围上下文中给定的类型。
在特定情况下，即使编译器错误地将捕获的变量声明为，只要is的函数运算符（这是您的情况， for is也不是），const您就可以在没有说明符的情况下使其工作。mutablefconstfmainmutable

让代码片段工作的另一种方法是这样的（如问题评论中所建议的）：

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

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

笔记。
正如在这个问题中所讨论的，问题是由于 GCC 的错误而引起的。使用的建议decltype(f)仍然有效。它还解决其他类型的问题并适用于特定情况。此外，如果错误得到修复，代码将继续正常工作。