Skip to content

Latest commit

 

History

History
154 lines (113 loc) · 10.6 KB

File metadata and controls

154 lines (113 loc) · 10.6 KB

条款二十四:区分通用引用与右值引用

Item 24: Distinguish universal references from rvalue references

据说,真相使人自由,然而在特定的环境下,一个精心挑选的谎言也同样使人解放。这一条款就是这样一个谎言。因为我们在和软件打交道,然而,让我们避开“谎言(lie)”这个词,不妨说,本条款包含了一种“抽象(abstraction)”。

为了声明一个指向某个类型T的右值引用,你写下了T&&。由此,一个合理的假设是,当你看到一个“T&&”出现在源码中,你看到的是一个右值引用。唉,事情并不如此简单:

void f(Widget&& param);             //右值引用
Widget&& var1 = Widget();           //右值引用
auto&& var2 = var1;                 //不是右值引用

template<typename T>
void f(std::vector<T>&& param);     //右值引用

template<typename T>
void f(T&& param);                  //不是右值引用

事实上,“T&&”有两种不同的意思。第一种,当然是右值引用。这种引用表现得正如你所期待的那样:它们只绑定到右值上,并且它们主要的存在原因就是为了识别可以移动操作的对象。

T&&”的另一种意思是,它既可以是右值引用,也可以是左值引用。这种引用在源码里看起来像右值引用(即“T&&”),但是它们可以表现得像是左值引用(即“T&”)。它们的二重性使它们既可以绑定到右值上(就像右值引用),也可以绑定到左值上(就像左值引用)。 此外,它们还可以绑定到const或者non-const的对象上,也可以绑定到volatile或者non-volatile的对象上,甚至可以绑定到既constvolatile的对象上。它们可以绑定到几乎任何东西。这种空前灵活的引用值得拥有自己的名字。我把它叫做通用引用universal references)。(Item25解释了std::forward几乎总是可以应用到通用引用上,并且在这本书即将出版之际,一些C++社区的成员已经开始将这种通用引用称之为转发引用forwarding references))。

在两种情况下会出现通用引用。最常见的一种是函数模板形参,正如在之前的示例代码中所出现的例子:

template<typename T>
void f(T&& param);                  //param是一个通用引用

第二种情况是auto声明符,它是从以上示例中拿出的:

auto&& var2 = var1;                 //var2是一个通用引用

这两种情况的共同之处就是都存在类型推导type deduction)。在模板f的内部,param的类型需要被推导,而在变量var2的声明中,var2的类型也需要被推导。同以下的例子相比较(同样来自于上面的示例代码),下面的例子不带有类型推导。如果你看见“T&&”不带有类型推导,那么你看到的就是一个右值引用:

void f(Widget&& param);         //没有类型推导,
                                //param是一个右值引用
Widget&& var1 = Widget();       //没有类型推导,
                                //var1是一个右值引用

因为通用引用是引用,所以它们必须被初始化。一个通用引用的初始值决定了它是代表了右值引用还是左值引用。如果初始值是一个右值,那么通用引用就会是对应的右值引用,如果初始值是一个左值,那么通用引用就会是一个左值引用。对那些是函数形参的通用引用来说,初始值在调用函数的时候被提供:

template<typename T>
void f(T&& param);              //param是一个通用引用

Widget w;
f(w);                           //传递给函数f一个左值;param的类型
                                //将会是Widget&,也即左值引用

f(std::move(w));                //传递给f一个右值;param的类型会是
                                //Widget&&,即右值引用

对一个通用引用而言,类型推导是必要的,但是它还不够。引用声明的形式必须正确,并且该形式是被限制的。它必须恰好为“T&&”。再看看之前我们已经看过的代码示例:

template <typename T>
void f(std::vector<T>&& param);     //param是一个右值引用

当函数f被调用的时候,类型T会被推导(除非调用者显式地指定它,这种边缘情况我们不考虑)。但是param的类型声明并不是T&&,而是一个std::vector<T>&&。这排除了param是一个通用引用的可能性。param因此是一个右值引用——当你向函数f传递一个左值时,你的编译器将会乐于帮你确认这一点:

std::vector<int> v;
f(v);                           //错误!不能将左值绑定到右值引用

即使一个简单的const修饰符的出现,也足以使一个引用失去成为通用引用的资格:

template <typename T>
void f(const T&& param);        //param是一个右值引用

如果你在一个模板里面看见了一个函数形参类型为“T&&”,你也许觉得你可以假定它是一个通用引用。错!这是由于在模板内部并不保证一定会发生类型推导。考虑如下push_back成员函数,来自std::vector

template<class T, class Allocator = allocator<T>>   //来自C++标准
class vector
{
public:
    void push_back(T&& x);
    …
}

push_back函数的形参当然有一个通用引用的正确形式,然而,在这里并没有发生类型推导。因为push_back在有一个特定的vector实例之前不可能存在,而实例化vector时的类型已经决定了push_back的声明。也就是说,

std::vector<Widget> v;

将会导致std::vector模板被实例化为以下代码:

class vector<Widget, allocator<Widget>> {
public:
    void push_back(Widget&& x);             //右值引用
    …
};

现在你可以清楚地看到,函数push_back不包含任何类型推导。push_back对于vector<T>而言(有两个函数——它被重载了)总是声明了一个类型为rvalue-reference-to-T的形参。

作为对比,std::vector内的概念上相似的成员函数emplace_back,却确实包含类型推导:

template<class T, class Allocator = allocator<T>>   //依旧来自C++标准
class vector {
public:
    template <class... Args>
    void emplace_back(Args&&... args);
    …
};

这儿,类型参数(type parameterArgs是独立于vector的类型参数T的,所以Args会在每次emplace_back被调用的时候被推导。(好吧,Args实际上是一个parameter pack,而不是一个类型参数,但是为了方便讨论,我们可以把它当作是一个类型参数。)

虽然函数emplace_back的类型参数被命名为Args,但是它仍然是一个通用引用,这补充了我之前所说的,通用引用的格式必须是“T&&”。你使用的名字T并不是必要的。举个例子,如下模板接受一个通用引用,因为形式(“type&&”)是正确的,并且param的类型将会被推导(重复一次,不考虑边缘情况,即当调用者明确给定类型的时候)。

template<typename MyTemplateType>           //param是通用引用
void someFunc(MyTemplateType&& param);

我之前提到,类型为auto的变量可以是通用引用。更准确地说,类型声明为auto&&的变量是通用引用,因为会发生类型推导,并且它们具有正确形式(T&&)。auto类型的通用引用不如函数模板形参中的通用引用常见,但是它们在C++11中常常突然出现。而它们在C++14中出现得更多,因为C++14的lambda表达式可以声明auto&&类型的形参。举个例子,如果你想写一个C++14标准的lambda表达式,来记录任意函数调用的时间开销,你可以这样写:

auto timeFuncInvocation =
    [](auto&& func, auto&&... params)           //C++14
    {
        start timer;
        std::forward<decltype(func)>(func)(     //对params调用func
            std::forward<delctype(params)>(params)...
        );
        stop timer and record elapsed time;
    };

如果你对lambda里的代码“std::forward<decltype(blah blah blah)>”反应是“这是什么鬼...?!”,只能说你可能还没有读Item33。别担心。在本条款,重要的事是lambda表达式中声明的auto&&类型的形参。func是一个通用引用,可以被绑定到任何可调用对象,无论左值还是右值。args是0个或者多个通用引用(即它是个通用引用parameter pack),它可以绑定到任意数目、任意类型的对象上。多亏了auto类型的通用引用,函数timeFuncInvocation可以对近乎任意(pretty much any)函数进行计时。(如果你想知道任意(any)和近乎任意(pretty much any)的区别,往后翻到Item30)。

牢记整个本条款——通用引用的基础——是一个谎言,噢不,是一个“抽象”。其底层真相被称为引用折叠reference collapsing),Item28的专题将致力于讨论它。但是这个真相并不降低该抽象的有用程度。区分右值引用和通用引用将会帮助你更准确地阅读代码(“究竟我眼前的这个T&&是只绑定到右值还是可以绑定任意对象呢?”),并且,当你在和你的合作者交流时,它会帮助你避免歧义(“在这里我在用一个通用引用,而非右值引用”)。它也可以帮助你弄懂Item2526,它们依赖于右值引用和通用引用的区别。所以,拥抱这份抽象,陶醉于它吧。就像牛顿的力学定律(本质上不正确),比起爱因斯坦的广义相对论(这是真相)而言,往往更简单,更易用。所以通用引用的概念,相较于穷究引用折叠的细节而言,是更合意之选。

请记住:

  • 如果一个函数模板形参的类型为T&&,并且T需要被推导得知,或者如果一个对象被声明为auto&&,这个形参或者对象就是一个通用引用。
  • 如果类型声明的形式不是标准的type&&,或者如果类型推导没有发生,那么type&&代表一个右值引用。
  • 通用引用,如果它被右值初始化,就会对应地成为右值引用;如果它被左值初始化,就会成为左值引用。