Effective Modern C++ 条款28 理解引用折叠

理解引用折叠

条款23提起过把一个实参传递给模板函数时,无论实参是左值还是右值,推断出来的模板参数都会含有编码信息。那条款没有提起,只有模板形参是通用引用时,这件事才会发生,不过对于这疏忽,理由很充分:条款24才介绍通用引用。把这些关于通用引用和左值/右值编码信息综合,意味着这个模板,

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

无论param是个左值还是右值,需要推断的模板参数T都会被编码。

编码技术是很简单的,当传递的实参是个左值时,T就被推断为一个左值引用,当传递的实参是个右值时,T就被推断为一个非引用类型。(注意这是不对称的:左值会编码为左值引用,但右值编码为非引用。)因此:

Widget widgetFactory();      // 返回右值的函数

Widget w;       // 一个变量,左值

func(w);      // 用左值调用函数,T被推断为Widget&

func(widgetFactory());     // 用右值调用函数,T被推断为Widget

两个func调用都是用Widget参数,不过一个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用一个左值进行初始化,param的类型应该出一个左值引用,但编译器是如何推断T的类型的,还有是怎样把它替代成下面这个样子,哪一个才是最终的签名呢?

void func(Widget& param);

答案是引用折叠。是的,你是禁止声明对引用的引用,但编译器在特殊的上下文中可以产生它们,模板实例化就是其中之一。当编译器生成对引用的引用时,引用折叠指令就会随后执行。

有两种类型的引用(左值和右值),所以有4种可能的对引用引用的组合(左值对左值,左值对右值,右值对左值,右值对右值)。如果对引用的引用出现在被允许的上下文(例如,在模板实例化时),这个引用(即引用的引用,两个引用)会折叠成一个引用,根据的是下面的规则:

如果两个引用中有一个是左值引用,那么折叠的结果是一个左值引用。否则(即两个都是右值引用),折叠的结果是一个右值引用。

在我们上面的例子中,在函数func中把推断出来的类型Widget&替代T后,产生了一个对右值的左值引用,然后引用折叠规则告诉我们结果是个左值引用。

引用折叠是使std::forward工作的关键部分。就如条款25解释那样,对通用引用使用std::forward,是一种常见的情况,像这样:

template<typename T>
void f(T&& fParam)
{
    ...        // do some works

    someFunc(std::forward<T>(fParam));   // 把fParam转发到someFunc
}

因为fParam是一个通用引用,我们知道无论传递给函数f的实参(即用来初始化fParam的表达式)是左值还是右值,参数类型T都会被编码。std::forward的工作是,当且仅当传递给函数f的实参是个右值时,把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);    }

在返回类型和cast中都会发生引用折叠,导致被调用的最终版本的std::forward

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

就如你所见,当一个左值被传递给模板函数f时,std::forward被实例化为接受一个左值引用和返回一个左值引用。std::forward内部的显式转换没有做任何东西,因为param的类型已经是Widget&了,所以这次转换没造成任何影响。一个左值实参被传递给std::forward,将会返回一个左值引用。根据定义,左值引用是左值,所以传递一个左值给std::forward,会导致std::forward返回一个左值,就跟它应该做的那样。

现在假设传递给函数f的是个右值的Widget。在这种情况下,函数f的类型参数T会被推断为Widget。因此f里面的std::forward会变成std::forward<Widget>。在std::forward的实现中用Widget代替T,像这样:

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,在命名空间std中
T&& forward(remove_reference_t<T>& param)
{
    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&。在声明中用Widget&代替auto声明w1,产生这个对引用进行引用的代码,

Widget& && w1 = w;

这在引用折叠之后,变成

Widget& w1 = w;

结果是,w1是个左值引用。

另一方面,这个声明

auto&& w2 = widgetFactory();

用个右值初始化w2,导致auto被推断为无引用类型Widget,然后用Widget替代auto变成这样:

Widget&& w2 = widgetFactory();

这里没有对引用的引用,所以我们已经完成了,w2是个右值引用。

我们现在处于真正能理解条款24介绍通用引用的位置了。通用引用不是一种新的引用类型,实际上它是右值引用——在满足了下面两个条件的上下文中:

  • 根据左值和右值来进行类型推断。T类型的左值使T被推断为T&,T类型的右值使T被推断为T。
  • 发生引用折叠

通用引用的概念是很有用的,因为它让你免受:识别出存在引用折叠的上下文,弱智地根据左值和右值推断上下文,然后弱智地把推断出的类型代进上下文,最后使用引用折叠规则。

我说过有4中这样的上下文,不过我们只讨论了两种:模板实例化和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;

引用折叠把代码弄出这样:

type int& RvalueRefToT;

这很明显的告诉我们,我们typedef选择的名字跟我们期望得到的不一样:当用左值引用实例化Widget时,RvalueRefToT是个左值引用的typedef

最后的一种会发生引用折叠的上下文是使用decltype中。如果,在分析一个使用decltype的类型期间,出现了对引用的引用,引用折叠会出面消除它。(关于decltype的详细信息,请看条款3。)

总结

需要记住的3点:

  • 引用折叠会出现在4中上下文:模板实例化,auto类型生成,typedef和类型别名声明的创建和使用,decltype
  • 当编译器在一个引用折叠上下文中生成了对引用的引用时,结果会变成一个引用。如果原来的引用中有一个是左值引用,结果就是个左值引用。否则,结果是个右值引用。
  • 通用引用是——出现在类型推断区分左值和右值和出现引用折叠的上下文中的——右值引用。
©️2020 CSDN 皮肤主题: 大白 设计师:CSDN官方博客 返回首页