目录
引用概述
引用：给已经存在的变量取个别名；编译器不会为引用变量开辟新的内存空间，它和引用的变量共用同一块内存空间；
例如：小明的小名叫作明明，不管是“明明”还是“小明”都指的是同一个人；
格式：类型& 引用变量名 = 被引用的实体；
//例如 ra 为 a 的引用
int a = 0;
int& ra = a;比较一下两个变量的地址是否相同；
//比较二者的地址
cout << &a << endl;
cout << &ra << endl;
引用变量的类型与引用实体的类型要相同；
int a = 0;
int& ra = a;
char ch = 'a';
char& rch = ch;引用在定义时必须初始化；
int a = 0;
int& ra = a;
//int& ra; //错误的写法一个变量可以有多个引用；
int a = 0;
int& b = a;
int& c = a;
//...引用变量只能引用一个实体。
int a = 0;
int b = 0;
int& ra = a;
ra = b; //不能再引用其他变量
//对比指针
int* pa = &a;
pa = &b;常量引用
引用常量时记得用 const 修饰，因为指针、引用在赋值或初始化时，权限可以缩小不能放大。
//1.
const int a = 0;
//int& ra = a; //编译时会报错，a为常量//权限放大
const int& ra = a; //权限保持
//int& b = 10; //错误写法，10为常量//权限放大
int c = 0;
const int& rc = c; //权限缩小
//2.
int Count()
{
int a = 0;
return a + 1;
}
int main()
{
//int& ret = Count(); //编译错误，Count 返回值为常量
const int& ret = Count();
return 0;
}
//3.
int a = 0;
//double& b = a; //类型错误
//double& b = (double)a; //编译错误，类型转换时会产生临时变量
const double& b = (double)a; //证明产生的临时变量具有常量性质使用场景：
1. 做参数
//形参的改变会影响实参，因为形参为实参的别名
void Swap(int& a, int& b)
{
int tmp = a;
a = b;
b = tmp;
}
//对比指针
void Swap(int* a, int* b)
{
int tmp = *a;
*a = *b;
*b = tmp;
}//顺序表
typedef struct SeqList
{
int* a;
int size;
int capacity;
}SL;
void SLPushBack(SL* ps, int data);//C语言中
void SLpushBack(SL& rs, int data);//C++中//单链表
typedef struct Node
{
int data;
struct Node* next;
}Node,*PNode;
void SLTPushBack(Node** pphead, int data);//C语言中
void SLTPushBack(Node*& phead, int data);//C++中
void SLTPushBack(PNode& phead, int data);//C++中2. 做返回值
引用作返回值时，如果函数返回时，出了函数作用域，如果返回对象还在(还没还给系统)，则可以使用引用返回，如果已经还给系统了，则必须使用传值返回。
int& Count()
{
static int n = 0;//出了作用域并未销毁，可用引用返回
n++;
return n;
}int& Add(int a, int b)
{
int c = a + b;//c出了作用域会被销毁，引用返回不可用
return c;
}
int main()
{
int& ret = Add(1, 2);
Add(3, 4);
cout << "Add(1, 2) is :" << ret << endl;//看似结果为3，实则不然
return 0;
}
引用作函数返回值时，调用函数时可修改返回对象；
#include<assert.h>
#define N 10
typedef struct Array {
int a[N];
int size = N;
}Array;
int& Test(Array& a, int i)
{
assert(i < N);
return a.a[i];
}
int main()
{
Array a;
for (int i = 0; i < N; i++)
{
Test(a, i) = i * 10;
}
for (int i = 0; i < N; i++)
{
cout << Test(a, i) << " ";
}
cout << endl;
return 0;
}
传值与传引用的效率比较
以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效率是非常低下的，尤其是当参数或者返回值类型非常大时，效率就更低。
//一组测试代码
#include <time.h>
struct A { int a[10000]; };
void TestFunc1(A a) {}
void TestFunc2(A& a) {}
void TestRefAndValue()
{
A a;
// 以值作为函数参数
size_t begin1 = clock();
for (size_t i = 0; i < 10000; ++i)
TestFunc1(a);
size_t end1 = clock();
// 以引用作为函数参数
size_t begin2 = clock();
for (size_t i = 0; i < 10000; ++i)
TestFunc2(a);
size_t end2 = clock();
// 分别计算两个函数运行结束后的时间
cout << "TestFunc1(A)-time:" << end1 - begin1 << endl;
cout << "TestFunc2(A&)-time:" << end2 - begin2 << endl;
}
int main()
{
TestRefAndValue();
return 0;
}
值和引用作为返回值的性能比较
//一组测试代码
#include <time.h>
struct A
{
int a[10000];
};
A a;
// 值返回
A TestFunc1() { return a; }
// 引用返回
A& TestFunc2() { return a; }
void TestReturnByRefOrValue()
{
// 以值作为函数的返回值类型
size_t begin1 = clock();
for (size_t i = 0; i < 100000; ++i)
TestFunc1();
size_t end1 = clock();
// 以引用作为函数的返回值类型
size_t begin2 = clock();
for (size_t i = 0; i < 100000; ++i)
TestFunc2();
size_t end2 = clock();
// 计算两个函数运算完成之后的时间
cout << "TestFunc1 time:" << end1 - begin1 << endl;
cout << "TestFunc2 time:" << end2 - begin2 << endl;
}
int main()
{
TestReturnByRefOrValue();
return 0;
}
引用与指针
引用与指针的用法及原理在我们使用者看来是不相同的（引用是给变量取别名，指针是指向变量的地址），但是其实引用的底层实现就是以指针的方式实现的。例如：
int main()
{
int a = 10;
int& ra = a;
ra = 20;
int* pa = &a;
*pa = 20;
return 0;
}对比一下指针与引用的汇编代码，发现二者底层实现完全相同。
那么既然底层实现相同，我们是不是就不用区别引用和指针了呢？当然不是，底层实现相同可不关咱们使用者什么事，在使用时我们依旧要注意二者的区别。
指针与引用的不同点：
1. 引用概念上定义一个变量的别名，指针存储一个变量地址；
2. 引用在定义时必须初始化，指针没有要求；
3. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体；
4. 没有 NULL 引用，但有 NULL 指针；
5. 在 sizeof 中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占4个字节)；
6. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小；
7. 有多级指针，但是没有多级引用；
8. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理；
9. 引用比指针使用起来相对更安全。
