c++右值引用

August 20, 2022

左值，右值

https://zh.cppreference.com/w/cpp/language/value_category

简单来说，变量名就是左值，变量的具体值就是右值。

cpp

int a = 1;
// 左值 右值

那么很明显，在 c++ 中可以获取一个左值的地址，而无法获取一个右值的地址。

纯右值：除字符串字面量以外的字面量（或由表达式产生）、临时（匿名）对象等。
亡值：即将被销毁但能够被移动的值（通过移动语义）。

左值引用

传统 c++ 引用就称左值引用，右值引用添加自 c++11

在左值引用中，一个引用变量名引用另一个变量名。

cpp

int a = 1;
int& ref = a;
ref = 2;
cout << a; // => 2

非常量的引用类型的变量无法引用一个右值，
不过常量引用类型则可以。

cpp

int &ref = 2; // ❎
// error: cannot bind non-const lvalue reference of type 'int&' to an rvalue of type 'int'

const int &ref = 2; // ✅

一个引用的引用相当于对原来那个变量的引用，类型仍然是原来那个变量的类型的引用。
（而不是引用的引用类型，这就引出了右值引用）

cpp

int a = 1;
int &ref = a;
int &&ref_ref = ref; // ❎，相当于 int &&ref_ref = a
// error: cannot bind rvalue reference of type 'int&&' to lvalue of type 'int'
int &ref_ref = ref;  // ✅

ref_ref = 2;
cout << a; // => 2

右值引用

右值引用可引用一个右值，而不能引用左值。

cpp

int a = 1;
int && rref = a; // ❎
// error: cannot bind rvalue reference of type 'int&&' to lvalue of type 'int'
int && rref = 1; // ✅

可以令右值引用重新引用另一个右值

cpp

int && rref = 1;
rref = 2;
cout << rref; // => 2

`std::move()` 将左值强制转换为右值

std::move 相当于 static_cast<T&&>(lvalue)，返回一个右值

cpp

int a = 1;
int && rref = a; // ❎
int && rref = std::move(a); // ✅

// move函数不发生所有权变化
cout << a; // => 1
a = 2;
cout << rref; // => 2

从形式上看，std::move(xxx) 作为一个表达式，是一个右值

cpp

int && rref = 1;
// 相当于
int temp = 1;
int && rref = std::move(temp);
cout << rref; // => 1
// 注意此函数参数仅对左值有效
int && rref = std::move(1);
cout << rref; // => 0

右值引用的这个变量名本身也是个左值。
如果有一个形参为右值引用的函数，该函数仅接受右值，那么就需要使用std::move函数

cpp

void use_rvalue(int && rvalue) {}

int a = 1;
int & lref = a;
int && rref = 1;
use_rvalue(1); // ✅
use_rvalue(a); // ❎
use_rvalue(lref); // ❎
use_rvalue(rref); // ❎
use_rvalue(std::move(a)); // ✅

不过，const 形参既能接受左值也能接收右值，但无法修改

cpp

void use_const(const int& n) {}
// 以下调用皆可通过编译
use_const(1);
int a = 1;
int & lref = a;
int && rref = 1;
use_const(a);
use_const(lref);
use_const(rref);
use_const(std::move(a));

移动语义

对于临时值来说，使用移动语义替代拷贝可提高性能。

给出一段修改自 cppreference 的演示代码如下：

cpp

#include <iostream>
#include <utility>
#include <vector>
#include <string>
using namespace std;

string wrap_string(string str){ return "\"" + str + "\""; }

int main()
{
    string str = "Hello";
    vector<string> v;

    // 使用 push_back(const T&) 重载，
    // 表示我们将带来复制 str 的成本
    v.push_back(str);
    cout << "After copy, str is " << wrap_string(str) << endl;

    // 使用右值引用 push_back(T&&) 重载，
    // 表示不复制字符串；而是
    // str 的内容被移动进 vector
    // 这个开销比较低，但也意味着 str 现在可能为空。
    v.push_back(std::move(str));
    std::cout << "After move, str is " << wrap_string(str) << endl;

    std::cout << "The contents of the vector are "
     << wrap_string(v[0]) << ", " << wrap_string(v[1]) << endl;
}

输出：

After copy, str is "Hello"
After move, str is ""
The contents of the vector are "Hello", "Hello"

移动语义的移动，指将某对象持有的资源或内容转移给另一个对象。
在转移资源后，被移动的对象处于有效但未定义的状态

移动一个 vector，不同于拷贝的是，这是通过移动构造函数而不是拷贝构造函数实现的。

cpp

vector<int> fibonacci = { 0, 1, 1, 2, 3, 5, 8};
cout << fibonacci.size() << endl; // => 7
vector<int> fib = move(fibonacci);
cout << fibonacci.size() << endl; // => 0

代码摘自https://zhuanlan.zhihu.com/p/347977300

cpp

class my_vector
{
    int* data_;
    size_t size_;
    size_t capacity_;

public:
    // 复制构造函数
    my_vector(const my_vector& oth) :
        size_(oth.size_),
        capacity_(oth.capacity_)
    {
        data_ = static_cast<int*>(malloc(sizeof(int) * size_));
        for (size_t i = 0; i < size_; ++i) {
            data_[i] = oth.data_[i];
        }
    }

    // 移动构造函数
    // std::exchange(obj, new_val)的作用是把返回obj的旧值，并把new_val赋值给obj
    my_vector(my_vector&& oth) :
        data_(std::exchange(oth.data_, nullptr)),
        size_(std::exchange(oth.size_, 0)),
        capacity_(std::exchange(oth.capacity_, 0))
    {}
};

`std::forward<>()` 完美转发

完美转发，指不仅转发参数的值，还保证被转发参数的左、右值属性不变。

cpp

#include <utility>
void use_rvalue(int&& rv) {}
void use_lvalue(int& lv) {}


void fn(int&& rvalue) {
    use_rvalue(rvalue); // 错误，rvalue 本身是个左值
    use_rvalue(std::move(rvalue)); // 将左值转换为右值
    use_rvalue(std::forward<int &&>(rvalue));  // 相当于上面

    use_lvalue(rvalue);  // 正确，需要传入左值
    use_lvalue(std::forward<int &>(rvalue)); // 相当于上面

}

int main() {
    int a = 1;
    fn(std::move(a));
}

参见

https://docs.microsoft.com/zh-cn/cpp/cpp/rvalue-reference-declarator-amp-amp
http://zh.cppreference.com/w/cpp/language/reference
https://zh.cppreference.com/w/cpp/utility/move
https://zh.cppreference.com/w/cpp/utility/exchange

←Back to home