条款23曾经提及，实参在传递给函数模板时，推导出来的模板形参会将实参是左值还是右值的信息编码到结果型别中。但该条款未曾提及，这个编码操作只有在实参被用以初始化的形参为万能引用时才会发生。不过，有一个充分的理由来解释为什么当时不提这茬：万能引用时在条款24中才介绍。把万能引用和左右值编码信息的论述综合起来，意思就是，以下面这个模板为例：

template<typename T>
void func(T&& param);

模板形参T的推导结果型别中，会把传给param的实参是左值还是右值的信息给编码进去。

编码机制是直截了当的：如果传递的实参是个左值，T的推导结果就是个左值引用型别；如果传递的实参是个右值，T的推导结果就是个非引用型别（注意这里的非对称性：左值的编码结果为左值引用型别，但右值的编码结果确是非引用型别）。是故有下面的结果：

Widget widgetFactory();  //返回右值的函数
Widget w;     //变量（左值）
func(w);      //调用func并传入左值：T的推导结果型别为Widget&
func(widgetFactory());   //调用func并传入左值：T的推导结果型别为Widget

两个对func的调用，传递的实参型别都为Widget.不同之处仅在于，一个是左值而另一个是右值，而这个不同之处却导致了针对模板形参T得出了不同的型别推导结果。这个机制，正如我们将很快看到的，就是决定了万能引用时编程左值引用还是右值引用的机制，也是std::forward得以运作的机制。

在我们以更深入细致的视角来观察std::forward和万能引用之前，我们必须注意一个事实，在C++中，“引用的引用”是非法的。你如果胆敢尝试声明一个，则编译器比会对此大加痛斥：

int x;
...
auto&& rx = x;  //错误！不可以声明引用的引用“”

但如果仔细琢磨一下，当左值被传递给接受万能引用的函数模板时会发生下面的状况：

template<typename T>
void func(T&& param);  //同前
func(w);     //调用func并传入左值：T的推导结果型别为Widget&

如果把T的推导结果型别（即Widget&）代码实例化模板，不就得到下面的结果了吗：

void func(Widget&& &param);

引用的引用！然而编译器却一声未吭。条款24告诉过我们，由于万能引用param是用左值初始化的，其推导结果型别理应是个左值引用，但编译器是如何取用了T的推导结果型别的，并带入模板，从而使它拥有了下面这个终极版函数签名呢？

void func(Widget& param);

答案就是引用折叠。是的，你是被禁止声明引用的引用，但编译器却可以在特殊的语境中产生引用的引用，模板实例化就是这样的语境之一。当编译器生成引用的引用时，引用折叠机制便支配了接下来发生的事情。

有两种引用（左值和右值），所以就有四种可能的引用——引用组合（左值-左值， 左值-右值，右值-左值，右值-右值）。如果引用的引用出现在允许的语境（例如，在模板实例化过程中），该双重引用会折叠成单个引用，规则如下：

如果任一引用为左值引用，则结果为左值引用。否则（即两个皆为右值引用），结果为右值引用。

在上述例子中，将推导结果型别Widget&代入函数模板func后，产生一个 指涉到左值引用的右值引用。尔后，根据引用折叠规则，结果是个左值引用。

引用折叠是使std::forward得以运作的关键。如同条款25所解释的那样，std::forward会针对万能引用实施，这么一来，就会出现如下的常见用例：

template<typename T>
void f(T&& fParam)
{...someFunc(std::forward<T>(fParam));  //将fParam转发至someFunc
}

由于fParam是个万能引用，我们就知道，传递给f的实参（即用以初始化fParam的表达式）是左值还是右值的信息会被编码到型别形参T中。std::forward的任务是，当且仅当编码T中的信息表明传递给实参是个右值，即T的推导结果型别是个非引用型别时，对fParam（左值）实施到右值的强制型别轮换。

这里是std::forward的一种能够完成任务的实现：

template<typename T>    //在名字空间std中
T&& forward(typename remove_reference<T>::type& param)
{return static_cast<T&&>(param);
}

这个实现和标准并不完全符合（我省去了若干接口细节），不过，那些我差异的部分对于理解std::forward的行为并无干系。

假设传递给函数f的实参的型别是个左值Widget,则T会被推导为Widget&型别，然后对std::forward的调用就会实例化为std::forward<Widget&>.而将Widget&插入std::forward的实现就会产生如下结果：

Widget& &&forward(typename remove_reference<Widget&>::type& param)
{return static_cast<Widget& &&>(param);
}

由于型别特征remove_reference<Widget&>::type的产生结果是Widget型别，所以std::forward又变换成了下面的结果：

Widget& && forward(Widget& param)
{return static_cast<Widget& &&>(param);
}

引用折叠同样在返回值和强制型别转换的语境中得到实施，导致实际结果调用是这样的终极版本std::forward:

Widget& forward(Widget& param)    //仍在名字空间std中
{return static_cast<Widget&>(param);
}

如你所见，当左值实参被传递给函数模板f时，std::forward实例化结果是：接受一个左值引用，并返回一个左值引用，而std::forward内部的强制型别转换未做任何事情，因为param的型别已经是Widget&了，所以再要把它强制转换到Widget&型别不会产生什么效果。综上，被传递给std::forward的左值实参会返回一个左值引用。根据定义，左值引用时左值，所以传递左值给std::forward会导致返回一个左值。符合认知。

再假设传递给f的实参是右值Widget型别。在此情况下，f的型别形参T的推导结果是个光秃秃的Widget.因此，f内部的std::forward就成了std::forward<Widget>。在std::forward的实现中，在T之处用Widget代入，就得出下面的代码：

Widget&& forward(typename remove_reference<Widget>::type& param)
{return static_cast<Widget&&>(param);
}

针对非引用Widget型别实施std::remove_reference会产生和起始型别相同的结果(Widget),所以std::forward又变成了这样：

Widget&& forward(Widget& param)
{return static_cast<Widget&&>(param);
}

这里没有发生引用的引用，所以也就没有发生引用折叠，所以这也就已经是本次std::forward调用的最终实例化版本了。

由函数返回的右值引用是定义为右值的，所以在此情况下，std::forward会把f的形参fParam（左值）转换成右值。最终的结果是，传递给函数f的右值实参会作为右值转发到someFunc函数，这也精确地符合认知。

在C++14中有了std::remove_reference_t，从而std::forward的实现得以变得更加简明扼要：

template<typename T>                          //C++14
T&& forward(remove_reference_t<T>& param)     //仍在名字空间std中
{return static_cast<T&&>(param);
}

引用折叠会出现的语境有四种。第一种，最常见的一种，就是模板实例化。第二种，是auto变量的型别生成。技术细节本质上和模板实例化一模一样，因为auto变量的型别推导和模板的型别推导在本质上就是一模一样的（参见条款2）。重新反思下本条款前面出现过的一个例子：

template<typename T>
void func(T&& param);Widget widgetFactory();   //返回右值的函数Widget w;                 //变量（左值）func(w);                  //以左值调用函数，T的型别推导结果为Widget&func(widgetFactory());    //以右值调用函数，T的型别推导结果为Widget

这一切都能以auto形式模仿。下面这个声明：

auto&& w1 = w;

初始化w1的是个左值，因此auto的型别推导结果为Widget&,在w1声明中以Widget&代入auto,就产生了一下这段涉及引用的引用的代码：

Widget& && w1 = w;

引用折叠之后，又会变成

Widget& w1 = w1;

这就是结果：w1乃是左值引用。

再看一例，下述声明：

auto&& w2 = widgetFactory();

以右值初始化w2，auto的型别推导结果为非引用型别Widget.将Widget代入auto就得到：

Widget&& w2 = widgetFactory();

这里并无引用的引用，所以到此结束：w2乃是右值引用。

话说到这里，我们才真正理解了条款24中介绍的万能引用。万能引用并非一种新的引用型别，其实它就是满足了下面两个条件的语境中的右值引用：

• 型别推导的过程会区别左值和右值。T型别的左值推导结果为T&，而T型别的右值则推导结果为T。
• 会发生引用折叠。

万能引用的概念是有用的，有了这个概念以后，就避免了需要识别出存在引用折叠的语境，根据左值和右值的不同脑补推导过程，然后再脑补针对推导的结果型别代入引用折叠发生的语境后应用引用折叠规则。

我曾在前面提及有四种会发生引用折叠的语境，不过目前只讨论过两种：模板实例化和auto型别生成。第三种语境是生成和使用typedef和别名声明（参见条款9）。如果在typedef的创建或者评估求值的过程中出现了引用的引用，引用折叠就会出手消灭之。例如，假设我们有个类模板Widget,内嵌一个右值引用型别的typedef,

template<typename T>
class Widget
{
public:typedef T&& RvalueRefToT;...
};

再假设我们以左值引用型别来实例化该Widget:

Widget<int&> w;

在Widget中以int& 代入T的位置，则得到如下的typedef:

typedef int& && RvalueRefToT;

引用折叠又将上述语句化简得到：

typedef int& RvalueRefToT;

这个结果显然表明，我们为typedef选择的名字也许有些名不符实：当以左值引用型别实例化Widget时，RvalueRefToT其实成了左值引用的typedef.

最后一种会发生引用折叠的语境在于decltype的运用中。如果在分析一个涉及decltype的型别过程中出现了引用的引用，则引用折叠亦会介入并消灭之（decltype详见条款3）

速记要点

• 引用折叠会在四种语境中发生：模板实例化、auto型别生成、创建和运用typedef和别名声明，以及decltype.
• 当编译器在引用折叠的语境下生成引用的引用时，结果会变成单个引用。如果原始的引用中有任一引用为左值引用。则结果为左值引用。否则，结果为右值引用。
• 万能引用就是在型别推导的过程会区别左值和右值，以及会发生引用折叠的语境中的右值引用。