c – 没有匹配函数std :: forward with lambdas

2023年10月10日 210次阅读

考虑以下代码,灵感来自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;
}

它没有编译因为这里提到的行,我不明白为什么：

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

显然使它工作,但再次,我不明白为什么,我的目标是实现功能的完美转发.

最佳答案 显然,编译器被修改或允许在不存在可变说明符时将副本捕获的变量声明为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函数的非const引用,因此F可以与lambda中的类型decltype(f)不同.
这在任何情况下都是有效的,即使对于可变的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是不可变的以及).

让你的代码段工作的另一种方法就是这样(正如问题的评论中所建议的那样)：

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

点赞