C++语法知识（21-40）

肖恩快跑~

已于 2024-03-18 15:45:30 修改

阅读量401

点赞数 7

分类专栏： C++ 文章标签： c++

于 2023-12-08 17:41:46 首次发布

本文链接：https://blog.csdn.net/qq_38496750/article/details/134884249

版权

C++ 专栏收录该内容

7 篇文章 0 订阅

订阅专栏

1. 省略号（…）用法

c++中的省略号

2. goto语句

c++关键字goto

3. C语言内存操作函数

memcpy()

【C语言】memcpy()函数(内存块拷贝函数)

4. std::is_same()判断两个类型是否相同

C++ 语言 std::is_same

5. decltype关键字

【C++深陷】之“decltype”

6. 左值、右值及其引用

左值和右值定义

网上关于左值、右值介绍的文章有很多，大多数文章都通过表达式能够出现在赋值号=的左、右来定义左右值，这样的定义对于读者不好理解，也没有表达出左右值的真实区别和意义。
文章C++左值（引用）和右值（引用）详解关于左右值的定义如下：
左值：在内存有确定存储地址、有变量名，表达式结束依然存在的值，简单来说左值就是非临时对象。
右值：就是在内存没有确定存储地址、没有变量名，表达式结束就会销毁的值，简单来说右值就是临时对象。

int a = 0;  // 在这条语句中，a 是左值，0 是临时值，就是右值。

该定义从对象的临时性角度定义左右值，能够表达出左右值的真实区别和存在的意义。

左值可以分为两类：非常量左值和常量左值；

int a=10;              	// a 为非常量左值（有确定存储地址，也有变量名）
const int a1=10;      //a1 为常量左值（有确定存储地址，也有变量名）
const int a2=20;      //a2 为常量左值（有确定存储地址，也有变量名）

同理，右值也可以分为两类：非常量右值和常量右值。

int a=10;              	// 10 为常量右值 （原文中说这事非常量右值，应该正好写反了）
const int a1=10;      
const int a2=20;      
a1+a2               	// (a1+a2) 为非常量右值

左值引用和右值引用

左值引用：其实就是绑定到左值的引用，通过&来获得左值引用；

int a=10;              //非常量左值（有确定存储地址，也有变量名）
const int a1=10;       //常量左值（有确定存储地址，也有变量名）
const int a2=20;       //常量左值（有确定存储地址，也有变量名）
 
//非常量左值引用
int &b1=a;            //正确，a是一个非常量左值，可以被非常量左值引用绑定
int &b2=a1;           //错误,a1是一个常量左值，不可以被非常量左值引用绑定
int &b3=10;           //错误，10是一个常量右值，不可以被非常量左值引用绑定
int &b4=a1+a2;        //错误,（a1+a2）是一个非常量右值，不可以被非常量左值引用绑定

//常量左值引用
const int &c1=a;      //正确，a是一个非常量左值，可以被非常量右值引用绑定
const int &c2=a1;     //正确,a1是一个常量左值，可以被非常量右值引用绑定
const int &c3=a+a1;   //正确，（a+a1）是一个常量右值，可以被常量右值引用绑定
const int &c4=a1+a2;  //正确,（a1+a2）是一个非常量右值，可以被非常量右值引用绑定

总结：非常量左值引用只能绑定到非常量左值上；常量左值引用可以绑定到非常量左值、常量左值、非常量右值、常量右值等所有的值类型。

右值引用：其实也是绑定到右值的引用，通过&&（中间无空格）来获得右值引用。

int a=10;             //非常量左值（有确定存储地址，也有变量名）
const int a1=20;      //常量左值（有确定存储地址，也有变量名）
const int a2=20;      //常量左值（有确定存储地址，也有变量名）

//非常量右值引用
int &&b1=a;            //错误，a是一个非常量左值，不可以被非常量右值引用绑定
int &&b2=a1;           //错误,a1是一个常量左值，不可以被非常量右值引用绑定
int &&b3=10;           //正确，10是一个非常量右值，可以被非常量右值引用绑定
int &&b4=a1+a2;        //错误,（a1+a2）是一个常量右值，不可以被非常量右值引用绑定

//常量右值引用
const int &&c1=a;      //错误，a是一个非常量左值，不可以被常量右值引用绑定
const int &&c2=a1;     //错误,a1是一个常量左值，不可以被常量右值引用绑定
const int &&c3=a+a1;   //正确，（a+a1）是一个非常量右值，可以被常量右值引用绑定
const int &&c4=a1+a2;  //正确,（a1+a2）是一个常量右值，不可以被常量右值引用绑定

总结：非常量右值引用只能绑定到非常量右值上；常量右值引用可以绑定到非常量右值、常量右值上。

从上述可以发现，常量左值引用可以绑定到右值上，但右值引用不能绑定任何类型的左值，若想利用右值引用绑定左值该怎么办呢？
C++11中提供了一个标准库move函数获得绑定到左值上的右值引用，即直接调用std::move告诉编译器将左值像对待同类型右值一样处理，但是被调用后的左值将不能再被使用。
std::move()函数举例：

int a=10;                 //非常量左值（有确定存储地址，也有变量名）
const int a1=20;          //常量左值（有确定存储地址，也有变量名）

//非常量右值引用
int &&d1=std::move(a);    //正确，将非常量左值a转换为非常量右值，可以被非常量右值引用绑定
int &&d2=std::move(a1);    //错误,将常量左值a1转换为常量右值，不可以被非常量右值引用绑定

//常量右值引用
const int &&c1=std::move(a);      //正确，将非常量左值a转换为非常量右值，可以被常量右值引用绑定
const int &&c2=std::move(a1);     //正确,将常量左值a1转换为常量右值，可以被常量右值引用绑定

最后可以发现，编译器利用std::move将左值强制转换为相同类型的右值之后，引用情况跟右值是一模一样的。