c++ - 没有与 lambda 匹配的函数 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 可以不同于类型 decltype(f ) 在 lambda 中。
这在任何情况下都是有效的，即使对于 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，只要 的函数运算符，您可以在没有 mutable 说明符的情况下使其工作f 是 const(这是你的情况，因为 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 说明符，我还是建议您采纳上述建议。

---

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