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

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

显然，当 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 副本的实际类型。请注意 original f 是对 lambda 函数的 non-const 引用，因此 F 可能与 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 的函数运算符是 [=14]，您可以在没有 mutable 说明符的情况下使其工作=]（这是你的情况，因为 f 是 main 也不是 mutable）。

让您的代码段起作用的另一种方法是（如问题评论中所建议）：

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) 的建议仍然有效。它还解决其他类型的问题并适用于特定情况。此外，如果错误得到修复，代码将继续正常工作。

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

No matching function std::forward with lambdas

c++

templates

lambda

c++14

perfect-forwarding