引用折叠和完美转发

阅读本文需要具有的预备知识:

  • 左值和右值的基本概念
  • 模板推导的基本规则
  • 若无特殊说明,本文中的大写字母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()的各个调用结果。

  1. 传入左值:

    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 & &&代码出来。它的理由就是:我(编译器)虽然推导出Tint&,但是我在最终生成的代码中,利用引用折叠规则,将int & &&等价生成了int &。推导出来的int & &&只是过渡阶段,最终版本并不存在。所以也不算破坏规定咯。

    关于有的人会问,我传入的是一个左值a,并不是一个左值引用,为什么编译器会推导出T 为int &呢。

    首先,模板函数参数为 T&& param,也就是说,不管T是什么类型,T&&的最终结果必然是一个引用类型。如果T是int, 那么T&& 就是 int &&;如果T为 int &,那么 T &&(int& &&) 就是&,如果T为&&,那么T &&(&& &&) 就是&&。很明显,接受左值的话,T只能推导为int &。

    1. 明白传入左值的推导结果,剩下的几个调用结果就很明显了:
    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 &param)
{
    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 &param)
    {
     return static_cast<int&&>(param);
    }

    param在forward内被强制类型转换为 int &&(static_cast<int&&>(param)), 然后按照int && 返回,两个右值引用最终还是右值引用。最终保持了实参的右值属性,转发正确。

  2. 传入 PrintType 实参是左值类型:

    根据以上的分析,可以知道T将被推导为左值引用类型,假设为int&。那么,将T = int& 带入forward。

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

    引用折叠一下就是:

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

    看到这里,我想就不用再多说什么了。传递给 PrintType 左值,forward返回一个左值引用,保留了实参的左值属性,转发正确。

到这里,完美转发也就介绍完毕了。

总结一下就是,通过引用折叠,我们实现了万能模板。在万能模板内部,利用forward函数,本质上是又利用了一遍引用折叠,实现了完美转发。其中,模板推导扮演了至关重要的角色。