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
  • 当编译器在一个引用折叠上下文中生成了对引用的引用时,结果会变成一个引用。如果原来的引用中有一个是左值引用,结果就是个左值引用。否则,结果是个右值引用。
  • 通用引用是——出现在类型推断区分左值和右值和出现引用折叠的上下文中的——右值引用。
Coming to grips with C++11 and C++14 is more than a matter of familiarizing yourself with the features they introduce (e.g., auto type declarations, move semantics, lambda expressions, and concurrency support). The challenge is learning to use those features effectively—so that your software is correct, efficient, maintainable, and portable. That’s where this practical book comes in. It describes how to write truly great software using C++11 and C++14—i.e. using modern C++. Topics include: The pros and cons of braced initialization, noexcept specifications, perfect forwarding, and smart pointer make functions The relationships among std::move, std::forward, rvalue references, and universal references Techniques for writing clear, correct, effective lambda expressions How std::atomic differs from volatile, how each should be used, and how they relate to C++'s concurrency API How best practices in "old" C++ programming (i.e., C++98) require revision for software development in modern C++ Effective Modern C++ follows the proven guideline-based, example-driven format of Scott Meyers' earlier books, but covers entirely new material. "After I learned the C++ basics, I then learned how to use C++ in production code from Meyer's series of Effective C++ books. Effective Modern C++ is the most important how-to book for advice on key guidelines, styles, and idioms to use modern C++ effectively and well. Don't own it yet? Buy this one. Now". -- Herb Sutter, Chair of ISO C++ Standards Committee and C++ Software Architect at Microsoft

“相关推荐”对你有帮助么?

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
©️2022 CSDN 皮肤主题:大白 设计师:CSDN官方博客 返回首页
评论 6
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、C币套餐、付费专栏及课程。

余额充值