文章目录

• 1. 概念
• 2. 关于别名的理解
• 3. 引用的特性
• • 1.引用必须在定义时初始化
  • 2.一个变量可以有多个别名
  • 3.引用一旦引用一个实体，再不能引用其他实体
• 4.使用场景
• • 1. 引用做参数
  • 2. 引用做返回值
  • • 1. 传值返回
    • • 是否为n直接返回
      • 临时变量作为返回值
    • 2. 传引用返回
    • • 编译器傻瓜式判断
      • 减少拷贝
      • 调用者修改返回对象
    • 3. 例题
• 5. 常引用
• • 权限放大
  • 权限保持
  • 权限缩小
  • 临时变量具有常性
  • 类型转换产生临时变量

1. 概念

• 引用不是新定义一个变量，而是给已存在的变量取别名，编译器不会为引用变量开辟内存空间，它和它引用的变量公用同一块内存空间

• 比如说 李逵，在家称为"铁牛"， 江湖上人称"黑旋风" 这两个称号都是他的
  

2. 关于别名的理解

#include
using namespace std;
int main()
{int a = 10;//引用int& b = a;b = 20;return 0;
}

• b是a的引用，也就是起了一个别名，a再取了一个名称
  
• 同时改变别名b的值，也会改变a本身的值

3. 引用的特性

1.引用必须在定义时初始化

#include
using namespace std;
int main()
{int a = 10;int& b;//错误举例return 0;
}

• 若使用引用不初始化，b是谁的别名？

2.一个变量可以有多个别名

#include
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
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
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
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
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
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
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;//7cout << "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
using namespace std;
int main()
{const int c = 2;int& d = c;//错误 权限放大return 0;
}

• c由const修饰,权限为只读， d权限为可读可写，将只读转化为可读可写是权限放大的表现，会报错
• 说明权限不可以放大

权限保持

#include
using namespace std;
int main()
{const int c = 2;const int& d = c;//权限保持return 0;
}

c的权限为只读，d的权限为只读
c和d的权限相同，可以使d作为c的别名
说明权限可以保持

权限缩小

#include
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
using namespace std;
int main()
{int i = 2;const double& d = i;
}

• i的值传给临时变量，临时变量类型为double，再使d作为临时变量的别名，临时变量具有常性，所以d要有const修饰