关于c++的右值引用

引用

A reference can be thought of as a name of an object.

• 左值引用: 引用左值.

• 右值引用: 引用右值, 用于参数传递, 函数返回值, 表达式中间结果. 类似于常量引用, 但是可以被修改.

(左值)引用类型的变量只能绑定到左值表达式, 只有const引用可以绑定到右值.
右值引用类型的变量只能绑定到右值表达式.

左值引用很好理解也经常用到, 右值引用还有点陌生, 接下来详细聊一聊.
引入右值引用是为了解决什么问题? 引入后又带来的什么新的问题? 新的问题又是怎么解决的?

引入右值引用是为了解决什么问题?

为了弥补C++在移动语义上的缺失. 在右值引用出现之前, 我们在函数调用传参时, 只有两种语义: 给它一份拷贝(按值传递), 或者给它一份引用(按引用传递).

那移动语义又是什么玩意儿? 为什么需要移动语义?

其实就是移动构造和移动赋值运算符, 把一个对象持有的资源转移给另一个新的对象, 避免先拷贝再释放资源的问题. 区别于已有的拷贝构造和赋值.

至于为什么需要, 无外乎是实践中有相应的使用场景.
比如std::unique_ptr, 它不能支持拷贝构造, 因为std::unique_ptr的语义就是要独占对象所有权.
这样一来函数要想返回一个std::unique_ptr就做不到了, 因为函数返回的时候要要构造一个新的std::unique_ptr, 自然就会涉及到拷贝构造.
有了移动语义就方便多了, 把原来的std::unique_ptr上的对象所有权转移到一个新的std::unique_ptr上并返回. 原来的std::unique_ptr随着函数结束自然销毁.

class unique_ptr {
public:

    unique_ptr(unique_ptr&& _Right) noexcept // 移动构造
    {
    }

    template <class _Dx2 = _Dx, enable_if_t<is_move_assignable_v<_Dx2>, int> = 0>
    unique_ptr& operator=(unique_ptr&& _Right) noexcept // 移动赋值
    {
        if (this != _STD addressof(_Right)) {
            reset(_Right.release());
            _Mypair._Get_first() = _STD forward<_Dx>(_Right._Mypair._Get_first());
        }
        return *this;
    }

    unique_ptr(const unique_ptr&) = delete;

    unique_ptr& operator=(const unique_ptr&) = delete;
};

引入后又带来的什么新的问题?

先看个例子, 下面代码中的foo(rref)会调到哪个实现foo会调到哪个重载?

void foo(int &)  { std::cout << "lvalue" << std::endl; }
void foo(int &&) { std::cout << "rvalue" << std::endl; }

int main() {
  int &&rref = 1;
  foo(rref);    // output: lvalue
}

答案是foo(int &), 是不是有点无法理解? 接着往下看.

foo(int &)接受一个左值类型的形参, 根据左值引用的规则, 左值引用类型的变量只能绑定左值. 所以, 要想匹配这个重载, 调用者必须传一个左值. 比如foo(a)

而foo(int &&)接受的是一个右值类型的形参, 根据右值引用的规则, 右值引用类型的变量只能绑定右值表达式. 所以, 要想匹配这个重载, 调用者必须传一个右值, 比如foo(99).

这很好理解, 神奇的地方在rref这个变量. rref的类型是int&&(右值引用), 绑定的值的类别是右值, 但有意思的是, 这个变量本身却是一个左值.

所以, 按照上面的重载匹配规则, 自然就匹配到了foo(int &).

这也就是引入右值引用后带来的问题:
变量类型和值类别, 变成了两个概念. 和左值引用表达式只能是左值不同, 右值引用类型的表达式既可以是左值也可以是右值.
重载匹配的时候右值引用类型的实参被当成了左值来用. 导致语义上出现错误.

新的问题又是怎么解决的?

标准库中提供了个std::move函数:

template <class _Ty>
constexpr remove_reference_t<_Ty>&& move(_Ty&& _Arg)
{
    return static_cast<remove_reference_t<_Ty>&&>(_Arg);
}

其实就是一个类型转换, 把传入的实参_Arg转换成一个右值.

所以, 上面的foo应该这样调:

int main() {
  int &&rref = 1;
  foo(std::move(rref));
  }

完美转发

上面讲的是最基础的场景, 接下来再看看和模板结合的场景:

void foo(int &)
{
    std::cout << "lvalue" << std::endl;
}

void foo(int &&)
{
    std::cout << "rvalue" << std::endl;
}

template<typename T>
int bar(T&& x)
{
    foo(x);
}

从语义上看, 我们希望给bar传一个左值时能够转调到foo的左值引用版本(foo(int&)),
当bar传一个右值时能够转调到foo的右值引用版本(foo(int&&)).

但是bar的形参x本身就是一个左值, 所以无论怎么传只能匹配到foo的左值引用版本, 显然达不到我们想要的目的.
这时候就需要完美转发了, 将函数实参以其原本的值类别转发出去. 标准库中提供了个std::forward函数.

所以上面的bar可以这么写:

template<typename T>
int bar(T&& x)
{
    foo(std::forward<T>(x));
}

扒一扒std::forward源码:

template <class _Ty>
constexpr _Ty&& forward(remove_reference_t<_Ty>& _Arg) noexcept
{
    return static_cast<_Ty&&>(_Arg);
}

template <class _Ty>
constexpr _Ty&& forward(remove_reference_t<_Ty>&& _Arg) noexcept
{
    static_assert(!is_lvalue_reference_v<_Ty>, "bad forward call"); // _Ty不能是左值引用类型
    return static_cast<_Ty&&>(_Arg);
}

其实就是一个静态类型转换, 传入左值的时候, 会匹配第一个重载, 这个重载根据_Ty的类型将实参转发为左值或右值. 传入右值时, 会匹配第二个重载, 这个重载根据_Ty的类型将实参转发为右值.
需要注意的是模板参数_Ty无法由编译器推断, 必须显式指定.

第一个重载不是很好理解, 补充一下展开过程:

• 模板参数传入int展开:

int && forward(int& _Arg) 
{
    return static_cast<int &&>(_Arg); // 按右值转发
}

• 模板参数传入int&展开:

int& && forward(int& _Arg) 
{
    return static_cast<int& &&>(_Arg); // 引用折叠, 折叠为int&, 按左值转发
}

• 模板参数传入int&&展开:

int&& && forward(int& _Arg)
{
    return static_cast<int&& &&>(_Arg); // 引用折叠, 折叠为int&&, 按右值转发
}

这里其实涉及到引用折叠和转发引用两个概念, 再补充说明一下:

o 引用折叠:

模板编程中参数类型推导出现双重引用时, 双重引用将被折叠成一个引用, 要么是左值引用, 要么是右值引用.
折叠规则是: 如果任一引用为左值引用, 则结果为左值引用, 否则(即两个都是右值引用), 结果为右值引用.

rvalue reference to rvalue reference collapses to rvalue reference, all other combinations form lvalue reference.

o 转发引用:
转发引用就是对一个待推导的类型 T 应用上右值引用的形式(T&&)。编译器在做类型推导时，会将绑定左值的T推导为左值引用类型，将绑定右值的T推导为原基本类型，再叠加引用坍缩规则后，绑定左值的变量的实际类型为左值引用，绑定右值的变量的实际类型为右值引用。

参考文献:

Everything about Rvalue Reference: https://www.zhihu.com/question/363686723/answer/1976488046
c++11的移动语义和完美转发: https://zhuanlan.zhihu.com/p/398817111