为什么模板化右值引用接受左值？

我看到类似的用法

#include <iostream>
#include <functional>
using namespace std;

template<typename FN>
void Foo(FN&& Fn)
{
    Fn();
}


void b()
{
    cout << "2." << endl;
}

int main() 
{
    Foo([](){ cout << "1." << endl; });
    Foo(&b);

    auto c = []() { cout << "3." << endl; };

    Foo(c);

    std::function<void(void)> d = c;

    Foo(d);

    return 0;
}

我相当确定“c”是一个左值，但我可以相信存在一些 lambda 类型推导恶作剧。但我几乎 100% 确定，d 是左值。

如果函数接受右值，但 d 是左值，为什么模板化的东西可以工作？

此外，为什么人们会这样写 Foo 的签名而不是仅仅这样

template<typename FN>
void Foo(FN Fn)

扣除规则T&&很棘手。

他们的目的是做出一个推论T&&“转发参考”（或“通用参考”）。

首先，参考崩溃。假设您有一个未知的 X 型。现在X没有被推导出来。

然后，如果我们检查以下类型的变量：

typedef X x0;
typedef X& x1;
typedef X const& x2;
typedef X&& x3;

我们设置X成为其中之一int, int&, int const& and int&&，我们得到：

X is --->  int         int&      int const&      int&&
X          int         int&      int const&      int&&
X&         int&        int&      int const&      int&
X const&   int const&  int&      int const&      int&
X&&        int&&       int&      int const&      int&&

活生生的例子.

接下来是扣除规则。如果你通过了X& to T&&在推论的背景下，T推论为X&。这导致T&&成为X&通过上述参考折叠规则。类似的事情发生在X const&.

如果你通过了X&& to T&&，它推导出T to be X. T&&变成X&&以及。

在他们两人之间，在推论的背景下，template<class T> void foo(T&&t)是一个通用引用（好吧，现在称为转发引用）。

您可以恢复 r/l 值类别t with std::forward<T>(t)，因此称为转发引用。

这允许一个模板处理 l 和 r 值，并使用std::forward如果你愿意的话，类似的机器的行为也会略有不同。

仅处理右值需要额外的工作：您必须使用 SFINAE 或其他重载（可能使用=delete）。仅处理左值很容易（只需推断T&).