一、 什么是左值、右值

首先不考虑引用以减少干扰,可以从2个角度判断:

  • 左值可以取地址、位于等号左边
  • 而右值没法取地址,位于等号右边

 

比如:

int num = 3;
  • num可以通过 & 取地址,位于等号左边,所以num是左值。
  • 3位于等号右边,3没法通过 & 取地址,所以3是个右值。
再者:

class Test {
public:
    Test(int num = 0) {
        _num = num;
    }
private:
    int _num;
};

void main(){
	Test test=Test();
}
  •  同样的,test可以通过 & 取地址,位于等号左边,所以test是左值。
  • Test()是个临时值,没法通过 & 取地址,位于等号右边,所以Test()是个右值。

因此,有地址的变量就是左值,没有地址的字面值、临时值就是右值。

 

 

二、什么是左值引用、右值引用

    引用本质是别名,可以通过引用修改变量的值,传参时传引用可以避免拷贝,其实现原理和指针类似。

1、左值引用

     顾名思义,左值引用=对左值的引用。能指向左值,不能指向右值的

int num = 3;
int &ref_num = num; // 左值引用指向左值,编译通过
int &ref_num = 3; // 左值引用指向了右值,会编译失败

引用是变量的别名,由于右值没有地址,没法被修改,所以左值引用无法指向右值。

但是,const左值引用是可以指向右值的:

const int &ref_num = 3;  // 编译通过

const左值引用不会修改指向值,因此可以指向右值。

正是这个原因,函数参数的用法:void Test(const std::string& value);void Test(const std::vector<std::string>& vet)等等。

 

 

2、右值引用

同理,右值引用=对右值的引用。能指向右值,不能指向左值的。

int &&right_num = 3; // ok
 
int num = 3;
int &&left_num = num; // 编译不过,右值引用不可以指向左值
 
right_num = 4; // 右值引用的用途:可以修改右值

 

三、右值引用能否指向左值

    在C++11中,引入了新特性:std::move

int num = 3; // num是个左值
int &left_num = num; // 左值引用指向左值
int &&right_num = std::move(num); // 通过std::move将左值转化为右值,可以被右值引用指向
 
cout << num; // 打印结果:3

本质:

  • 其实std::move语义其本质并非将一个值移动到另一个值,释放原内存。
  • 而是把左值强制转化为右值,让右值引用可以指向左值。
  • 其实现等同于一个类型转换:static_cast<T&&>(lvalue)

同理,右值引用能指向右值,本质上也是把右值提升为一个左值,并定义一个右值引用通过std::move指向该左值:

int &&ref_num = 3;
ref_num = 4; 

等同于以下代码:
int temp = 30;
int &&ref_num = std::move(temp);
ref_num = 40;

 

四、左值引用、右值引用本身是左值还是右值?

     被声明出来的左、右值引用都是左值。 因为被声明出的左右值引用是有地址的,也位于等号左边。

// 形参是个右值引用
void ChangeValue(int&& right_value) { 
     right_value = 8;
}

int main() {
int num = 3; // a是个左值
int &ref_a_left = num // ref_a_left是个左值引用
int &&ref_a_right = std::move(a); // ref_a_right是个右值引用

ChangeValue(num); // 编译不过,num是左值,change参数要求右值
ChangeValue(ref_a_left); // 编译不过,左值引用ref_a_left本身也是个左值
ChangeValue(ref_a_right); // 编译不过,右值引用ref_a_right本身也是个左值

ChangeValue(std::move(a)); // 编译通过
ChangeValue(std::move(ref_a_right)); // 编译通过
ChangeValue(std::move(ref_a_left)); // 编译通过

change(5); // 当然可以直接接右值,编译通过

// 打印这三个左值的地址,都是一样的
cout << &num << ' ';
cout << &ref_a_left << ' ';
cout << &ref_a_right;
}

 

最后,std::move会返回一个右值引用int &&,它是左值还是右值呢?

        从表达式int &&ref = std::move(num)来看,右值引用ref指向的必须是右值,所以move返回的int &&是个右值。所以右值引用既可能是左值,又可能是右值吗? 确实如此:右值引用既可以是左值也可以是右值,如果有名称则为左值,否则是右值

 

结论:

1、从性能上讲,左右值引用没有区别,传参使用左右值引用都可以避免拷贝。

2、右值引用可以直接指向右值,也可以通过std::move指向左值;而左值引用只能指向左值(const左值引用也能指向右值)。

3、作为函数形参时,右值引用更灵活。虽然const左值引用也可以做到左右值都接受,但它无法修改,有一定局限性。

 

 

代码上的实践

// std::vector和std::string的实际例子
int main() {
    std::string str1 = "aacasxs";
    std::vector<std::string> vec;
     
    vec.push_back(str1); // 传统方法,copy
    vec.push_back(std::move(str1)); // 调用移动语义的push_back方法,避免拷贝,str1会失去原有值,变成空字符串
    vec.emplace_back(std::move(str1)); // emplace_back效果相同,str1会失去原有值
    vec.emplace_back("axcsddcas"); // 当然可以直接接右值
}

在vector和string这个场景,加个std::move会调用到移动语义函数,避免了深拷贝。

可移动对象在<需要拷贝且被拷贝者之后不再被需要>的场景,建议使用std::move触发移动语义,提升性能。

比如:

moveable_objecta = moveable_objectb; 
改为: 
moveable_objecta = std::move(moveable_objectb);

还有些STL类是move-only的,比如unique_ptr,这种类只有移动构造函数,因此只能移动(转移内部对象所有权,或者叫浅拷贝),不能拷贝(深拷贝):

std::unique_ptr<Test> ptr_test1 = std::make_unique<Test>();

// unique_ptr只有‘移动赋值重载函数‘,参数是&& ,只能接右值,因此必须用std::move转换类型
std::unique_ptr<Test> ptr_test2 = std::move(ptr_test1); // 编译不通过
std::unique_ptr<Test> ptr_test2 = ptr_test1; 

std::move本身只做类型转换,对性能无影响。 我们可以在自己的类中实现移动语义,避免深拷贝,充分利用右值引用和std::move的语言特性。

 

 

此外,还有完美转发 std::forward,不过forward多用于模板,后续再补吧。。。

 

分类:

技术点:

相关文章: