文章目录
- 1. 概念
- 2. 关于别名的理解
- 3. 引用的特性
- 1.引用必须在定义时初始化
- 2.一个变量可以有多个别名
- 3.引用一旦引用一个实体，再不能引用其他实体
- 4.使用场景
- 1. 引用做参数
- 2. 引用做返回值
- 1. 传值返回
- 是否为n直接返回
- 临时变量作为返回值
- 2. 传引用返回
- 编译器傻瓜式判断
- 减少拷贝
- 调用者修改返回对象
- 3. 例题
- 5. 常引用
- 权限放大
- 权限保持
- 权限缩小
- 临时变量具有常性
- 类型转换产生临时变量
1. 概念
-
引用不是新定义一个变量，而是给已存在的变量取别名，编译器不会为引用变量开辟内存空间，它和它引用的变量公用同一块内存空间
-
比如说 李逵，在家称为"铁牛"， 江湖上人称"黑旋风" 这两个称号都是他的
2. 关于别名的理解
#include<iostream>
using namespace std;
int main()
{
int a = 10;//引用
int& b = a;
b = 20;
return 0;
}
- b是a的引用，也就是起了一个别名，a再取了一个名称
- 同时改变别名b的值，也会改变a本身的值
3. 引用的特性
1.引用必须在定义时初始化
#include<iostream>
using namespace std;
int main()
{
int a = 10;
int& b;//错误举例
return 0;
}
- 若使用引用不初始化，b是谁的别名？
2.一个变量可以有多个别名
#include<iostream>
using namespace std;
int main()
{
int a = 10;
int& b = a;
int& c = a;
int& d = a;
return 0;
}
- b、c、d都是a的别名
3.引用一旦引用一个实体，再不能引用其他实体
#include<iostream>
using namespace std;
int main()
{
int a = 10;
int& b = a;
int c = 2;
b = c;
return 0;
}
- 由于b与c的地址不同，说明b不是c的别名 b值与c值相等，而是将c的值传给b
4.使用场景
1. 引用做参数
#include<iostream>
using namespace std;
void swap(int& pa, int& pb)
{
int tmp = pa;
pa = pb;
pb = tmp;
}
int main()
{
int a = 1;
int b = 2;
swap(a, b);
cout << "a= " << a <<" "<<"b=" << b << endl;
return 0;
}
把pa作为a的别名，即a本身
把pb作为b的别名，即b本身
pa与pb的交换就可以看作a与b的交换
2. 引用做返回值
1. 传值返回
是否为n直接返回
#include<iostream>
using namespace std;
int count()
{
int n = 0;
n++;
return n;
}
int main()
{
int ret=count();
return 0;
}
正常来说，是把n直接给ret，但是局部变量n随着count函数的销毁而销毁
所以ret再次访问到到原来函数栈帧，就会造成非法访问
所以说明并不是使用n作为返回值
临时变量作为返回值
将临时变量作为返回值
编译器是将n的值给予一个临时变量，临时变量的类型是int，再通过临时变量传给ret
临时变量通常是由寄存器(存4个字节/8个字节)充当
2. 传引用返回
编译器傻瓜式判断
#include<iostream>
using namespace std;
int count()
{
static int n = 0;
n++;
return n;
}
int main()
{
int ret=count();
return 0;
}
static修饰后n在静态区，所以count栈帧的销毁不影响n，虽然n的值存在，但是依旧要通过临时变量来传递返回值，因为编译器是傻瓜式的处理问题.
此时临时变量是没必要存在，所以我们可以采用引用返回
减少拷贝
编译器将n的值传给临时变量，类型是int&，相当于n的别名，
再把临时变量传给ret，相当于将n本身传给ret，减少拷贝
调用者修改返回对象
#include<iostream>
using namespace std;
#define N 100
typedef struct arry//静态数组
{
int a[N];
int size;
}ay;
int& posat(ay& arr,int i)//传引用返回，返回的是arr.a[i]本身
{
return arr.a[i];
}
int main()
{
ay arr;
int i = 0;
for ( i = 0; i < N; i++)
{
posat(arr, i) = i;//将arr.a[i]的值进行赋值
}
for (i = 0; i < N; i++)//打印静态数组的值
{
cout << posat(arr, i) << " ";
}
return 0;
}
出了posat作用域还在，因为ay.a[i]属于结构体的局部变量，所以可以使用传引用返回，从而修改静态数组的值
3. 例题
#include<iostream>
using namespace std;
int& Add(int a, int b)
{
int c = a + b;
return c;
}
int main()
{
int& ret = Add(1, 2);
Add(3, 4);
cout << "Add(1,2) is :" << ret << endl;//7
cout << "Add(1,2) is :" << ret << endl;//随机值
return 0;
}
- 这个程序本身是错误的，结果是未定义的
- 先调用Add(1,2)，由于是传引用返回，将c值3传给临时变量(作为c值的别名)，再将临时变量传给ret，即ret是临时变量的别名，同理，ret也为c值的别名 (若Add栈帧销毁后空间没有被清理，ret值为3，若空间被清理，则为随机值)
- 调用同一个函数，建立栈帧大小相同，c处于位置也是相同，(若Add栈帧销毁后空间没有被清理，ret值为7，若空间被清理，则为随机值)
- 第一次空间未被清理，ret值为7，cout是一次函数调用，会建立函数栈帧覆盖掉Add栈帧，所以下一次为随机值
5. 常引用
权限放大
#include<iostream>
using namespace std;
int main()
{
const int c = 2;
int& d = c;//错误 权限放大
return 0;
}
- c由const修饰,权限为只读， d权限为可读可写，将只读转化为可读可写是权限放大的表现，会报错
- 说明权限不可以放大
权限保持
#include<iostream>
using namespace std;
int main()
{
const int c = 2;
const int& d = c;//权限保持
return 0;
}
c的权限为只读，d的权限为只读
c和d的权限相同，可以使d作为c的别名
说明权限可以保持
权限缩小
#include<iostream>
using namespace std;
int main()
{
int a = 5;
const int& b = a;//权限缩小
return 0;
}
a的权限为可读可写，b的权限为只读，b可以作为a的别名
说明权限可以缩小
临时变量具有常性
int count()
{
int n = 0;
n++;
return n;
}
int main()
{
const int& ret = count();
return 0;
}
- 传值返回，返回的是临时变量，ret作为临时变量的别名，临时变量具有常性，所以需加const修饰ret
类型转换产生临时变量
#include<iostream>
using namespace std;
int main()
{
int i = 2;
const double& d = i;
}
- i的值传给临时变量，临时变量类型为double，再使d作为临时变量的别名，临时变量具有常性，所以d要有const修饰
