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

显然，当const说明符不存在时，编译器会被窃听或允许将副本捕获的变量声明为mutable。
具有讽刺意味的是，以下内容与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)类型不同。
这在任何情况下都是有效的，即使对于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的函数运算符为{{1}，就可以使其在没有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说明符，我也建议采纳上述建议。

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

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

1 个答案: