当前位置：首页 > news >正文

C++语法—引用

news 来源：原创 2024/9/28 3:51:31

引用变量

概念

简单理解就是对一个已存在的变量起别名，与那个已存在的变量共用一块内存空间。
用法：已存在变量的类型 & 引用变量名 = （引用实体）已存在变量

int main()
{int a = 1;int& b = a;return 0;
}

在上面这个示例代码中，b是a的引用变量，我们可以通过a去输出1,也可以通过b来输出1，相当于给张三这个人起了个绰号叫张山，无论是叫张山还是张三代指都是一个人。

语法规定

引用在定义时必须初始化
一个变量可以有多个引用
引用一旦引用一个实体，再不能引用其他实体

引用与指针的区别

虽然在语法概念上引用就是一个，没有独立空间，和其引用实体共用同一块空间，但是底层实现是有空间，因为引用是按照指针方式来实现的

int main()
{   int a = 1;int& ra = a;int b = 2;ra = b;//这里只是把b的值赋值给ra,不是改变引用对象//&ra = &b;//引用一旦给定初值无法改变方向cout << b << endl;cout << ra << endl;//而指针可以改变指向int* pa = &a;pa = &b;(*pa)++;cout << b << endl;return 0;
}

引用和指针的不同点:

引用概念上定义一个变量的别名，指针存储一个变量地址。
引用在定义时必须初始化，指针没有要求
引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体
没有NULL引用，但有NULL指针
在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)
引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小
有多级指针，但是没有多级引用
访问实体方式不同，指针需要显式解引用，引用编译器自己处理
引用比指针使用起来相对更安全

引用的使用场景

传参

在这里插入图片描述 swap1是传值传参，在swap1中，a和b 不过是main函数的拷贝，所以改变swap1的a和b，不能改变main函数的a和b。而swap2是传址传参，在swap2中，a和b是main函数中a和b的别名，所以能够改变他，而且传引用传参不会发生拷贝构造，也会提高效率

常引用参数、临时变量

其实由上面的例子来看，swap1的传值引用会产生临时匿名对象，然后再拷贝到函数参数中，会调用该类的拷贝构造。
但是在某些传引用传参也会产生临时匿名对象（在被const修饰的前提之下，为什么？因为临时匿名对象具有常性,所以只有加const才能引用他）

实参的类型正确，但实参是右值
发生隐式类型转换

比如：

double refcube(const double &ra)
{return ra*ra*ra;
}
double side = 3.0;
long edge = 5L;
double c1 = refcube(side); // ra is side 
double c2 = refcube(edge);// edge是long类型，发生隐式类型转换
double c3 = refcube(7.0);// 7.0是字面量是右值
double c7 = refcube(side + 10.0); // side + 10.0是将亡值 也是右值的一种

总结：哪几种场景会产生临时变量??

隐形类型转换比如:intb=0 float a=b b在赋值到a时候编译器会产生临时变量再去赋值给a
函数传值传参
函数返回值

函数返回

int& Add1(int a, int b)
{int c = a + b;return c;
}int Add2(int a, int b)
{int c = a + b;return c;
}int main()
{int& ret1 = Add1(1, 2);//ret1是Add1中c的引用int ret2 = Add1(1, 2);//隐式类型转换int ret3 = Add2(1, 2);//返回的时候把Add2的临时里面对象给拷贝到ret3const int& ret4 = Add2(1, 2);//把他的临时匿名对象给引用了cout << "ret1 is :" << ret1 << endl;cout << "ret2 is :" << ret2 << endl;cout << "ret3 is :" << ret3 << endl;cout << "ret4 is :" << ret4 << endl;return 0;
}

在这里插入图片描述
为什么得出以上结果？
ret1是Add1中c的引用，c是add函数中的变量，生命周期会在离开add函数的时候销毁，所以引用的虽然是c，但是c已经在函数返回的时候还给内存了，所以是随机值。
注意：如果函数返回时，出了函数作用域，如果返回对象还在(还没还给系统)，则可以使用引用返回，如果已经还给系统了，则必须使用传值返回。
ret2是3 本质上其实是 int c = 3 返回变量 int temporary& = c; ret2 = temporary。其实也是拷贝构造
ret3是典型的传值返回，返回的时候把Add2的临时里面对象给拷贝到ret3
ret4是引用类型，它把Add2的返回值引用了，因为临时匿名对象具有常性，所以要用const修饰

右值引用

字面量、常量、变量

字面量：顾名思义就是我们人在读这个变量的，可以里面懂的他代指的含义。const int a = 16 16就是字面量，而被const修饰的只读的变量就是常量。如果a没有被const修饰那就是变量。

左值、右值、将亡值

左值：是一个表示数据的表达式(如变量名或解引用的指针)，我们可以获取它的地址+可以对它赋值，左值可以出现赋值符号的左边，右值不能出现在赋值符号左边。定义时const修饰符后的左值，不能给他赋值，但是可以取它的地址。

int main()
{// 以下的p、b、c、*p都是左值int* p = new int(0);int b = 1;const int c = 2;// 以下几个是对上面左值的左值引用int*& rp = p;int& rb = b;const int& rc = c;int& pvalue = *p;return 0;
}

右值：也是一个表示数据的表达式，如：字面常量、表达式返回值，函数返回值(这个不能是左值引用返回)等等，右值可以出现在赋值符号的右边，但是不能出现出现在赋值符号的左边，右值不能取地址。

int main()
{double x = 1.1, y = 2.2;// 以下几个都是常见的右值10;x + y;fmin(x, y);// 以下几个都是对右值的右值引用int&& rr1 = 10;double&& rr2 = x + y;double&& rr3 = fmin(x, y);// 这里编译会报错：error C2106: “=”: 左操作数必须为左值10 = 1;x + y = 1;fmin(x, y) = 1;return 0;
}

将亡值：即将还给内存的值，一些临时匿名对象。

概念

之前学习的引用都是左值引用，而右值引用就是对右值起别名
右值引用语法：引用类型 && 引用名 = 右值

右值引用的作用

其实左值引用也可以对右值取别名，比如：a+b表达式是右值，我们可以这样写const int& ret2 = (a + b); 因为临时匿名对象具有常性，我们加上const就可以对他引用了，也可以使用右值引用 int&& ret2 = (a + b); 如果你要使用右值引用引用左值的话可以使用move函数，他会返回一个右值给引用变量int a = 1; int&& b = move(a);
其实对于已经存在左值引用的情况下，为什么要弄一个右值引用呢？

void func(const int& a)
{cout << "void func(int& a)" << endl;
}//void func(int&& a)
//{
//	cout << "void func(int&& a)" << endl;
//}int main()
{int a = 0;int b = 1;func(a);func(a + b);
}

void func(int& a)
{cout << "void func(int& a)" << endl;
}void func(int&& a)
{cout << "void func(int&& a)" << endl;
}int main()
{int a = 0;int b = 1;func(a);func(a + b);
}

右值引用的第一个意义是在之前只有左值引用的时候，如果我们对右值引用要在前面+const 去修饰参数，可读性不强，难区分左右值传参，而现在多了右值引用我们可以利用传参不同构成函数重载，来增加明确的可读性。
再看一段代码：

int main()
{Jaxsen::string s1("hello");Jaxsen::string ret1 = s1;Jaxsen::string ret2 = (s1+'!');return 0;
}

在ret1 = s1上，本质是s1调用了拷贝构造把ret1深拷贝到ret1中，然后我们再去看ret2 = (s1 + '!' )，首先s1 +'!'是一个右值，对于这个右值我们是否有必要对他进行深拷贝呢？在ret1 = s1我们之所以要做深拷贝是因为避免同一个变量指向同一块内存，导致我改变ret1,s1也会跟着改变。但是在s1 +'!'这个右值表达式中产生出来的结果是一个将亡值，它的生命周期将会在这个表达式运算完就还给内存了，我们根本不用去担心访问冲突的关系。所以移动拷贝就出来了。

移动拷贝

什么是移动拷贝？
简单的理解就是把那些临时匿名对象，没有名字的变量，用右值引用变量管理那块要还给操作系统的内存。省去深拷贝，提高了效率。
注意：右值引用的根本作用不是减少拷贝，大部分的减少拷贝左值引用已经完成了

string operator+(char ch)
{string tmp(*this);tmp += ch;return tmp;
}

在这里插入图片描述
在上面代码执行的时候，可以观察出ret2的地址和operator+中的tmp是一个地址。
左值引用解决直接减少拷贝，相当于传指针，不过没有指针那么复杂。而左值引用没有解决的是函数内的局部对象不能用引用返回的问题。
看下面场景：

class Solution {
public:vector<vector<int>> generate(int numRows) {vector<vector<int>> vv;vv.resize(numRows);//给定开辟有多少个vector<int>//给每一个vector<int>开辟空间for(int i = 0;i<vv.size();i++){vv[i].resize(i+1);}//把杨辉三角的每一行的首元素和尾元素置为1for(int i = 0;i<numRows;i++){vv[i][0] = 1;vv[i][vv[i].size()-1] =1;}//执行逻辑：上一行的前一位+上一行的当前位 =当前位for(int i = 2;i < numRows;i++){for(int j = 1;j < vv[i].size() - 1;j++){vv[i][j] = vv[i-1][j-1]+vv[i-1][j];}}return vv;   }
};

在这样的一个杨辉三角问题中，我们需要在generate函数中构建临时对象vv,然后还传值返回，在传值返回的时候深拷贝构建临时匿名对象，去复制给外面的接收又要深拷贝，而且这返回值根本不用担心访问冲突的问题，没有必要做深拷贝。所以右值这就是引用的第二个意义。

move

int main()
{string s1("hello");cout << "第一次赋值" << endl;string s2 = s1;cout << s1 << endl;cout << s2 << endl;cout << "第二次赋值" << endl;string&& s3 = move(s1);cout << s1 << endl;cout << s3 << endl;cout << "第三次赋值" << endl;string s4 = move(s1);cout << s1 << endl;cout << s4 << endl;return 0;
}

在这里插入图片描述
为什么会有这样的输出，请解释赋值语句的含义？
第一次赋值语句是将对象s1赋值给s2，发生深拷贝把s1的值拷贝一份给s2，相当于在内存中开多一块空间存放与s1一样的值，不过是s2管。
第二次赋值语句是将对象s1move成了右值，然后用右值引用变量去给该值起别名，s3和s1都有管理这片内存的权限，和左值引用没有什么区别。
第三次是s1变成右值交给s4去管理，发生了移动拷贝，把s1原本管理的内存交给s4去管理，s1被置为了null。所以不能轻易的把左值move右值然后又赋值给其他变量，这样原本的那个左值会失去对该内存的管理。

完美转发

void Fun(int& x) { cout << "左值引用" << endl; }
void Fun(const int& x) { cout << "const 左值引用" << endl; }void Fun(int&& x) { cout << "右值引用" << endl; }
void Fun(const int&& x) { cout << "const 右值引用" << endl; }// 万能引用(引用折叠)：既可以引用左值，也可以引用右值
template<typename T>
void PerfectForward(T&& t)
{Fun(t);
}int main()
{PerfectForward(10);           // 右值int a;PerfectForward(a);            // 左值PerfectForward(std::move(a)); // 右值const int b = 8;PerfectForward(b);		      // const 左值PerfectForward(std::move(b)); // const 右值return 0;
}

在这里插入图片描述
为什么是这个输出结果？
再看一个案例

int main()
{int&& rr1 = 10;cout << &rr1 << endl;rr1++;cout << rr1 << endl;return 0;
}

在这里插入图片描述
10是字面量而rr1右值引用变量引用之后就可以取地址和做++运算，得出结论：当右值被右值引用变量引用之后就转化为了左值，或者说右值引用变量是左值。
为什么要这样设计呢？因为只有这样才可以对右值进行操作（移动构造）。
我们再回到上面那一题目,我们可以得出结论，在我们将右值作为函数参数传递给右值引用的时候，那个参数就变成了左值，所以输出的就是左值。

forward

含义：在传参的过程中保留对象原生类型属性
使用方法：forward<原生类型>（变量）
上面修改后：

void Fun(int& x) { cout << "左值引用" << endl; }
void Fun(const int& x) { cout << "const 左值引用" << endl; }void Fun(int&& x) { cout << "右值引用" << endl; }
void Fun(const int&& x) { cout << "const 右值引用" << endl; }// 万能引用(引用折叠)：既可以引用左值，也可以引用右值
template<typename T>
void PerfectForward(T&& t)
{Fun(forward<T>(t));
}int main()
{PerfectForward(10);           // 右值int a;PerfectForward(a);            // 左值PerfectForward(std::move(a)); // 右值const int b = 8;PerfectForward(b);		      // const 左值PerfectForward(std::move(b)); // const 右值return 0;
}