原文：
https://zhuanlan.zhihu.com/p/50816420
阅读本文需要具有的预备知识：
- 左值和右值的基本概念
- 模板推导的基本规则
- 若无特殊说明，本文中的大写字母T泛指任意的数据类型
引用折叠
我们把 引用折叠 拆解为 引用和 折叠 两个短语来解释。
首先，引用的意思众所周知，当我们使用某个对象的别名的时候就好像直接使用了该对象，这也就是引用的含义。在C++11中，新加入了右值的概念。所以引用的类型就有两种形式：左值引用T&和右值引用T&&。
其次，解释一下折叠的含义。所谓的折叠，就是多个的意思。上面介绍引用分为左值引用和右值引用两种，那么将这两种类型进行排列组合，就有四种情况：
- 左值-左值 T& &
- 左值-右值 T& &&
- 右值-左值 T&& &
- 右值-右值 T&& &&
这就是所谓的引用折叠！引用折叠的含义到这里就结束了。
但是，当我们在IDE中敲下类似这样的代码：
// ...
int a = 0;
int &ra = a;
int & &rra = ra; // 编译器报错：不允许使用引用的引用！
// ...
WTF ! 既然不允许使用，为啥还要有引用折叠这样的概念存在 ？!
原因就是：引用折叠的应用场景不在这里！！
下面我们介绍引用折叠在模板中的应用：完美转发。在介绍完美转发之前，我们先介绍一下万能引用。
万能引用
所谓的万能引用并不是C++的语法特性，而是我们利用现有的C++语法，自己实现的一个功能。因为这个功能既能接受左值类型的参数，也能接受右值类型的参数。所以叫做万能引用。
万能引用的形式如下：
template<typename T>
ReturnType Function(T&& parem)
{
// 函数功能实现
}
接下来，我们看一下为什么上面这个函数能万能引用不同类型的参数。
为了更加直观的看到效果，我们借助Boost库的部分功能，重写我们的万能引用函数：
如果不了解Boost库也没关系，Boost库主要是为了帮助大家看到模板里参数类型）
#include <iostream>
#include <boost/type_index.hpp>
using namespace std;
using boost::typeindex::type_id_with_cvr;
template<typename T>
void PrintType(T&& param)
{
// 利用Boost库打印模板推导出来的 T 类型
cout << "T type：" << type_id_with_cvr<T>().pretty_name() << endl;
// 利用Boost库打印形参的类型
cout << "param type:" << type_id_with_cvr<decltype(param)>().pretty_name() << endl;
}
int main(int argc, char *argv[])
{
int a = 0; // 左值
PrintType(a); // 传入左值
int &lvalue_refence_a = a; // 左值引用
PrintType(lvalue_refence_a); // 传入左值引用
PrintType(int(2)); // 传入右值
}
通过上面的代码可以清楚的看到，void PrintType(T&& param)可以接受任何类型的参数。嗯，真的是万能引用！到这里的话，万能引用的介绍也就结束了。但是我们只看到了这个东西可以接受任何的参数，却不知道为什么它能这么做。
下面，我们来仔细观察并分析一下main函数中对PrintType()的各个调用结果。
传入左值
int a = 0; // 左值
PrintType(a); // 传入左值
/***************************************************/
输出：T type : int &
param type : int &
我们将T的推导类型int&带入模板，得到实例化的类型：
void PrintType(int& && param)
{
// ...
}
重点来了！编译器将T推导为 int& 类型。当我们用 int& 替换掉 T 后，得到 int & &&。
MD，编译器不允许我们自己把代码写成int& &&，它自己却这么干了 =。=
那么 int & &&到底是个什么东西呢？！（它是引用折叠，刚开始就说了啊 =。=）
下面，就是引用折叠的精髓了。
所有的引用折叠最终都代表一个引用，要么是左值引用，要么是右值引用。
规则就是：
如果任一引用为左值引用，则结果为左值引用。否则（即两个都是右值引用），结果为右值引用。
《Effective Modern C++》
也就是说，int& &&等价于int &。void PrintType(int& && param) == void PrintType(int& param)
所以传入右值之后，函数模板推导的最终版本就是：
void PrintType(int& param)
{
// ...
}
所以，它能接受一个左值a。
现在我们重新整理一下思路：编译器不允许我们写下类似int & &&这样的代码，但是它自己却可以推导出int & &&代码出来。它的理由就是：我(编译器)虽然推导出T为int&，但是我在最终生成的代码中，利用引用折叠规则，将int & &&等价生成了int &。推导出来的int & &&只是过渡阶段，最终版本并不存在。所以也不算破坏规定咯。
关于有的人会问，我传入的是一个左值a,并不是一个左值引用，为什么编译器会推导出T 为int &呢。
首先，模板函数参数为 T&& param,也就是说，不管T是什么类型，T&&的最终结果必然是一个引用类型。如果T是int, 那么T&& 就是 int &&；如果T为 int &，那么 T &&(int& &&) 就是&，如果T为&&,那么T &&(&& &&) 就是&&。很明显，接受左值的话，T只能推导为int &。
2.明白传入左值的推导结果，剩下的几个调用结果就很明显了：
int &lvalue_refence_a = a; //左值引用
PrintType(lvalue_refence_a); // 传入左值引用
/*
* T type : int &
* T && : int & &&
* param type : int &
*/
PrintType(int(2)); // 传入右值
/*
* T type : int
* T && : int &&
* param type : int &&
*/
以上就是万能引用的全部了。总结一下，万能引用就是利用模板推导和引用折叠的相关规则，生成不同的实例化模板来接收传进来的参数。
完美转发
好了，有了万能引用。当我们既需要接收左值类型，又需要接收右值类型的时候，再也不用分开写两个重载函数了。那么，什么情况下，我们需要一个函数，既能接收左值，又能接收右值呢？
答案就是：转发的时候。
于是，我们马上想到了万能引用。又于是兴冲冲的改写了以上的代码如下：
/*
* Boost库在这里已经不需要了，我们将其拿掉，可以更简洁的看清楚转发的代码实现
*/
#include <iostream>
using namespace std;
// 万能引用，转发接收到的参数 param
template<typename T>
void PrintType(T&& param)
{
f(param); // 将参数param转发给函数 void f()
}
// 接收左值的函数 f()
template<typename T>
void f(T &)
{
cout << "f(T &)" << endl;
}
// 接收右值的函数f()
template<typename T>
void f(T &&)
{
cout << "f(T &&)" << endl;
}
int main(int argc, char *argv[])
{
int a = 0;
PrintType(a);//传入左值
PrintType(int(0));//传入右值
}
我们执行上面的代码，按照预想，在main中我们给 PrintType 分别传入一个左值和一个右值。PrintType将参数转发给 f() 函数。f()有两个重载，分别接收左值和右值。
正常的情况下,PrintType(a);应该打印f(T&),PrintType(int());应该打印f(T&&)。
但是，真实的输出结果是
f(T &);
f(T &);
为什么明明传入了不同类型的值，但是void f()函数只调用了void f(int &)的版本。这说明，不管我们传入的参数类型是什么，在void PrintType(T&& param)函数的内部，param都是一个左值引用！
没错，事实就是这样。当外部传入参数给 PrintType 函数时，param既可以被初始化为左值引用，也可以被初始化为右值引用，取决于我们传递给 PrintType 函数的实参类型。但是，当我们在函数 PrintType 内部，将param传递给另一个函数的时候，此时，param是被当作左值进行传递的。 应为这里的 param 是个具名的对象。我们不进行详细的探讨了。大家只需要己住，任何的函数内部，对形参的直接使用，都是按照左值进行的。
WTF，万能引用内部形参都变成了左值！那我还要什么万能引用啊！直接改为左值引用不就好了！！
别急，我们可以通过一些其它的手段改变这个情况，比如使用 std::forward 。
在万能引用的一节，我们应该有所感觉了。使用万能引用的时候，如果传入的实参是个右值(包括右值引用)，那么，模板类型 T 被推导为 实参的类型（没有引用属性），如果传入实参是个左值，T被推导为左值引用。也就是说，模板中的 T 保存着传递进来的实参的信息，我们可以利用 T 的信息来强制类型转换我们的 param 使它和实参的类型一致。
具体的做法就是，将模板函数void PrintType(T&& param)中对f(param)的调用，改为f(std::forward<T>(param));然后重新运行一下程序。输出如下：
f(T &);
f(T &&);
嗯，完美的转发！
那么，std::forward是怎么利用到 T 的信息的呢。
std::forward的源码形式大致是这样：
/*
* 精简了标准库的代码，在细节上可能不完全正确，但是足以让我们了解转发函数 forward 的了
*/
template<typename T>
T&& forward(T ¶m)
{
return static_cast<T&&>(param);
}
我们来仔细分析一下这段代码：
我们可以看到，不管T是值类型，还是左值引用，还是右值引用，T&经过引用折叠，都将是左值引用类型。也就是forward 以左值引用的形式接收参数 param, 然后 通过将param进行强制类型转换 static_cast<T&&> （），最终再以一个 T&&返回
所以，我们分析一下传递给 PrintType 的实参类型，并将推导的 T 类型代入 forward 就可以知道转发的结果了。
1.传入 PrintType 实参是右值类型：
根据以上的分析，可以知道T将被推导为值类型，也就是不带有引用属性，假设为 int 。那么，将T = int 带入forward。
int&& forward(int ¶m)
{
return static_cast<int&&>(param);
}
param在forward内被强制类型转换为 int &&(static_cast<int&&>(param)), 然后按照int && 返回，两个右值引用最终还是右值引用。最终保持了实参的右值属性，转发正确。
2.传入 PrintType 实参是左值类型：
根据以上的分析，可以知道T将被推导为左值引用类型，假设为int&。那么，将T = int& 带入forward。
int& && forward(int& ¶m)
{
return static_cast<int& &&>(param);
}
引用折叠一下就是：
int& forward(int& param)
{
return static_cast<int&>(param);
}
看到这里，我想就不用再多说什么了。传递给 PrintType 左值，forward返回一个左值引用，保留了实参的左值属性，转发正确。
到这里，完美转发也就介绍完毕了。
总结一下就是，通过引用折叠，我们实现了万能模板。在万能模板内部，利用forward函数，本质上是又利用了一遍引用折叠，实现了完美转发。其中，模板推导扮演了至关重要的角色。
