右值和右值引用与std::move()的内在联系是啥，完美转发与引用折叠为何如此难解，一篇博文让你彻底开悟

本是古典何须时尚 2022-11-20 08:26 115阅读 0赞

# 右值和右值引用与std::move()的内在联系是啥，完美转发与引用折叠为何如此难解，一篇文章让你彻底开悟 #

`std::move()`是一个C++标准模板库的函数模板，它的作用是：输入一个左值对象，输出一个相应的`无名右值引用`，而无名右值引用本质上就是右值。  
上面是从宏观层面进行了理解，现在我的问题是，`std::move()`函数会对输入的左值对象产生哪些影响？会不会让这个左值对象立刻失效？这句代码执行完后，对刚刚输入的左值对象操作还有效吗？

通常出现这些问题是因为根本没有理解`std::move()`函数的运行机制。

要想搞清楚这个函数到底做了什么，需要了解一些铺垫性的内容，铺垫行的内容有：左值，左值引用，右值，具名右值引用，转发型引用，引用的折叠机制和`static_cast<>()`类型转变这些内容。下面进行灵魂介绍：

左值：左值就是程序员实际创建的类型对象，该对象是有变量名的，一旦创建了该类型对象，就会有专属于该对象的内存地址，并且这个对象名会关联到该块内存地址，就不会出现无人认领该块内存的现象，反之，如果我们创建的对象(如`new Person`但没有用`Person*`类型的变量名来绑定这一对象)没有被绑定到某一变量名上，则该对象就是一个临时对象，即将被销毁，这个临时对象就是右值对象。

右值：所谓右值，就是不能放到`=`的左边，即不能被赋值的值。那么顺着这个思路往下捋，什么样的对象不适合被赋值呢？那一定是没有内存地址，或者是有内存地址但是没有变量名绑定在该对象上的对象。例如字符串`interesting subject`或者字数字`110`这种字面量，他本是是不能被赋值的，但是可以用来初始化或赋值给左值对象，如`int a = 5; const char* str = "Benjamin";a = 100; str = "abc" ;`；再就是函数返回的临时对象，虽然这些临时对象可能有内存地址，但也是右值，因为如果没有利用`右值引用`或`常量左值引用`去绑定接管它，那么返回的该对象会很快被销毁，即便不销毁，由于没有绑定也抓不住该临时对象，编译器对不可使用的临时对象会进行立即销毁，以免占用栈空间内存。

左值引用：左值引用就是来绑定左值对象的，该左值对象本身是有变量名关联该对象地址的，这和`具名右值引用`不同，`具名右值引用`只能绑定`右值`，而右值对象自身是没有变量名与之关联的，所以一旦右值引用本身失效或被销毁，则具名右值引用所绑定的右值对象会立即消失。

右值引用：右值引用本身也是一种引用，它绑定的是临时对象，并不会创建对象。由于绑定临时对象时也使用了变量名，所以右值引用自身是左值，可以被赋值。但是有一点要注意：右值引用所绑定的对象本身是没有变量名的。

记住：

*  无名的右值引用是右值（这个很好理解，因为即便函数返回了右值引用类型的对象，但该右值引用对象却没有变量名做绑定，那他就是右值）
 *  具名的右值引用是左值（有名字，就是有变量名，那么这个右值引用本身便是左值）

`转发型引用`：转发型引用出现再函数模板中，这种类型的引用既可以绑定左值，也可以绑定右值，关键是看具体的实参是什么类型，如果实参是左值，则转发行引用会对该实参进行左值绑定。其类型如下：

template<typename T>
    void outer(T&& t) // 函数模板的形参列表中的 T&& 就是转发型引用
    {  }

如果传递的实参是右值(临时对象)，则转发型引用会对该实参进行右值绑定。所以转发型引用俗称“万能引用”。关于转发型引用的深刻理解，就不得不提“引用折叠”机制，下面进行介绍

`引用折叠机制`：引用折叠进制是为了进行类型推导，从而能够很好的保障`完美转发`的实现。想象一下下面的函数模板`outer(T&& t)`是怎么推导出类型T的是`左值引用`还是`右值或右值引用`？没有折叠机制，基本不可能理解。

/// forward
      template<typename _Tp>
        inline _Tp&&
        forward(typename std::remove_reference<_Tp>::type& __t) 
        {  return static_cast<_Tp&&>(__t); }
     
      template<typename _Tp>
        inline _Tp&&
        forward(typename std::remove_reference<_Tp>::type&& __t) 
        { 
          static_assert(!std::is_lvalue_reference<_Tp>::value, "template argument"
    		    " substituting _Tp is an lvalue reference type");
          return static_cast<_Tp&&>(__t);
        }

折叠机制的思想是：对于函数模板的形参转发型引用`T&& t`，当传递进来的实参是左值时，并且该左值的具体类型为`U`类型，则`t`便是左值引用`U&`，即此时有`T&& 等价于 U&`；当传递进来的实参是右值时(实参的具体类型同上，`U`类型)，则`t`便是右值引用`U&&`类型，此时`T&&`等价于`U&&`。  
再明确一点，右值概念的丰富、右值引用的提出，本身是为了提升C++程序运行的效率，因为有些临时对象如果不加以好好地利用，就是浪费资源，性能损耗的表现，所以对待右值，或者说对待临时对象，我们希望尽可能的榨取他们的剩余价值，能转移资源控制权的地方，就不要使用拷贝赋值来开辟空间从而拖慢执行效率。只有明白了这一点，我们才能明白在程序设计和开发中，当我们在聚焦于某些对象的右值或右值属性时，我们究竟在想什么，究竟想怎么用这些右值对象的资源。

template<typename T>
    void outer(T&& t) {  // 注意这里的T&& 是转发型引用，不要把他错误的理解为右值引用，转发行引用上面有介绍
        inner(forward<T>(t)); // 这里利用forward<>()函数模板就是为了实现完美转发
    }

接下来，我们就根据上述思想逆向推导引用折叠机制，从设计引用折叠机制的设计者视角(上帝视角)来看看为什么会出现这样的规则，现在我们聚焦于`forward`函数模板，forward函数模板想做的事情就是`完美转发`，之所以看着和函数模板，是因为引用折叠机制其实主要是为完美转发而引入的规则。所谓完美转发，就是转发函数接收到的参数时左值时，那么它就按照左值引用的方式把该形参传递出去，转发函数接收到的函数参数是右值时，那么它就按照右值引用的方式把该形参传递出去，从而保证传递的过程不会改变原始实参的左右值属性，对于不同的左右值属性，可能最终的处理函数会重载不同的执行逻辑，最终会体现到程序的运行效率和资源的利用率上。按照这样的思想，那么一切都变得明朗了。我们能明确知道根据传递进来什么样的参数类型(主要是区分左右值)就传递出去与之匹配的类型，那么所涉及的规则就应该是这种映射关系。

所以：

*  传递的实参是左值时，转发函数的形参`t`便是左值引用`U&`，此时`T&&`等价于`U&`，我们希望传递出去的依然是左值引用从而保持左值属性，所以类型`T`应该推导为`U&`，即`U& + &&`等价于`U&`①。注意加号`+`后面的`&&`是转发型引用的部分，在类型推导中属于固定格式。
 *  传递的实参是右值时，转发函数的形参`t`便是右值引用`U&&`，此时`T&&`等价于`U&&`，我们希望传递传递出去的参数依然是右值引用从而保持右值属性，此时类型`T`既可以是右值`U`，也可以是右值引用`U&&`，因为无论是哪一种，只要和右值有关就行，`forward<>()`模板函数都会将`右值引用t`转变为无名无名右值引用(还是右值)，从而保证传递的右值属性到达最终调用函数形参列表时没有发生变化。即`U + &&`等价于`U&&`②、`U&& + &&`等价于`U&&`③

以上三条内容(数字标号)就是引用折叠机制的主要内容。

静态类型转换操作符`static_cast<>()`，在圆括号`()`输入要转换变量名，在尖括号`<>`中输入要转换的目标类型，该类型转换操作符便会输出你想要的目标类型，注意static\_cast<>()并不会使输入的变量对象失效，之前的对象名还是可以用的，但是也要看我们的目的是啥，并不是弄出一个其他类型随便玩玩。static\_cast<>()可以根据输入的左值引用输出该对象的一个左值引用对象或右值引用，也可以在不同类型的指针之间进行转换，但不管是那种类型的转换，请注意一定要在同种类型范畴中转换，跨越类型范畴的转化没有意义也不会成功编译。

有了以上这些铺垫，就能够看懂下面的`std::move()`和`std::forward()`函数源代码了

### std::move ###

> std::move(t) 负责将表达式 t 转换为右值，使用这一转换意味着你不再关心 t 中的内容，它可以通过被移动（窃取）来解决**移动语意**问题。

源代码与测试代码

template<typename _Tp>
    // 注意：这一行的typename表示它后面的标识符是类型名，而不是变量名，为了消除歧义
        inline typename std::remove_reference<_Tp>::type&& 
        move(_Tp&& __t)
        {  return static_cast<typename std::remove_reference<_Tp>::type&&>(__t); }

#include<iostream>
    using namespace std;
     
    struct X { };
     
    int main()
    { 
    	X a;
    	X&& b = move(a);
    	X&& c = move(X());
    }

### std::forward ###

> std::forward(u) 有两个参数：T 与 u。当T为左值引用类型时，u将被转换为T类型的左值引用(属于左值的一种)，否则u将被转换为T类型右值(其实是无名右值引用，属于右值的一种)。如此定义std::forward是为了在使用右值引用参数的函数模板中解决参数的完美转发问题。

源代码与测试代码

#include<iostream>
    using namespace std;
     
    struct X { };
    void inner(const X&) { cout << "inner(const X&)" << endl;}
    void inner(X&&) { cout << "inner(X&&)" << endl;}
    template<typename T>
    void outer(T&& t) { inner(forward<T>(t));}
     
    int main()
    { 
    	X a;
    	outer(a);
    	outer(X());
    	inner(forward<X>(X()));
    }
    
    //inner(const X&)
    //inner(X&&)
    //inner(X&&)

关于上述代码的具体解释，可以参看本人的另一篇博客：[https://blog.csdn.net/qq\_35866736/article/details/107676826][https_blog.csdn.net_qq_35866736_article_details_107676826]

[https_blog.csdn.net_qq_35866736_article_details_107676826]: https://blog.csdn.net/qq_35866736/article/details/107676826