C++入门级教程：引用的超超超详细攻略

一、引用的特点

1、一个变量可以有多个引用
2、引用必须初始化
3、引用的指向不能改变（一旦引用一个实体，再不能引用其他实体）。
4、同一作用域不能引用同名引用。
5、不能返回局部对象的引用

二、引用的作用：
1、引用做参数（输出型参数）

C语言：形参的改变不改变实参
C++：形参是实参的别名

#include<iostream>
using namespace std;
//或把常用的展开
//using std::cout;
//using std::endl;

//函数重载
//C++允许在同一作用域声明几个功能类似的同名函数（参数个数、类型、类型顺序不同）（且自动匹配类型)（返回值没有要求）（但是有可能产生调用歧义）


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;
}

int main()
{
    int x = 0, y = 1;
    int* px = &x;
    int* py = &y;
    Swap(x, y); //交换数值
    Swap(px, py); //交换地址
    cout << x << " " << y << " " << endl;//cout可自动识别类型，endl等价于\n(换行）
    cout << px << " " << py << " " << endl;
    return 0;
}

2、引用做参数（减少拷贝提高效率）（大对象/深拷贝类对象）

3、引用做返回值（减少拷贝提高效率）
C语言中传值返回：局部变量，静态区变量全局变量都会生成拷贝
C++中传引用返回：不生成临时变量，减少拷贝提高效率

#include<iostream>
using namespace std;

int Count1()//传值返回
{
	static int n = 1;
	n++;
	return n;
}

int& Count2()//引用返回
{
	static int n = 1;
	n++;
	return n;
}

int& Count3()//引用返回的错误用法
{
	int n = 1;
	n++;
	return n;
}

int main()
{
	int ret1 = Count1();//Count生成临时对象后赋值给ret
	int ret2 = Count2();//引用返回不生成临时对象
	int ret3 = Count3();
	cout << ret1 << endl;
	cout << ret2 << endl;
	cout << ret3 << endl;//结果不确定
	//如果函数结束，栈帧销毁，未清理栈帧，则结果侥幸是正确的
	//如果函数结束，栈帧销毁，清理栈帧，则返回值为随机值
	return 0;
}

局部对象用引用返回（不会报错，就像越界不一定报错）：销毁空间，归还使用权后，后续相当于野指针访问，结果打印为随机值（如果函数结束，栈帧销毁，但没有清理栈帧，那么结果侥幸是正确的）如：（栈帧覆盖）

#include<iostream>
using namespace std;

int& Count(int x)//引用返回的错误用法
{
	int n = x;
	n++;
	return n;
}

int main()
{
	int& ret = Count(10);
	cout << ret << endl;//输出10
	Count(100);
	cout << ret << endl;//VS2019输出101（栈帧覆盖）
	return 0;
}

总结：
基本任何场景都可以用引用传参。
谨慎用引用做返回值，出了函数作用域，对象不在了就不能引用返回，还在或全局对象或malloc就可以用引用返回。

4、引用做返回值（修改返回值）

#include<assert.h>
#include<iostream>
using namespace std;

struct Seqlist
{
	int a[100];
	size_t size;
};

void Modify(Seqlist* list, int pos, int x)
{
	assert(pos >= 0 && pos <= 100);
	list->a[pos] = x;
}

int SLGet(Seqlist* list, int pos)//传值返回
{
	assert(pos >= 0 && pos <= 100);
	return list->a[pos];
}

int& SLat(Seqlist* list, int pos)//传引用返回（读写皆可）
{
	assert(pos >= 0 && pos <= 100);
	return list->a[pos];
}

int main()
{
	Seqlist s;
   //C语言写法
	Modify(&s, 10, 100);
	cout << SLGet(&s, 10) << endl;
	int ret = SLGet(&s, 10);
	Modify(&s, 10, ret + 5);
	cout << SLGet(&s, 10) << endl;
   //C++写法
	SLat(&s, 10) = 100;
	cout << SLat(&s, 10) << endl;
	SLat(&s,10) += 5;
	cout << SLat(&s, 10) << endl;
}

引用过程中，权限不能放大，可以平移或者缩小（但是只会缩小别名的权限）

int func1(){
    static int x = 0;
    x++;
    return x;
}

int& func2(){
    static int x = 0;
    x++;
    return x;
}

int main()
{
    int a = 0;
    int& b = a;//权限的平移

    const int c = 0;
    //int& d = c;//引用过程中，权限不能放大
    int d = c;
    //int* pc = &c;//指针涉及权限放大与引用类似

    int e = 0;
    const int f = e;//权限的缩小
    ++e;

    const int& m = 10;//权限的平移

    double dd = 1.1;
    int ii = dd;//隐式类型转换
    //int& ii = dd;//产生了临时变量，具有常性
    const int& rii = dd;

    const int& ret1 = func1();
    int& ret2 = func2();

    return 0;
}

注：

只要产生类型转换，就会生成临时变量，临时变量具有常性（就像被const修饰一样）

若整形提升，则一般由范围小的向范围大的提升（int--->double）

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

有兴趣的小伙伴还可以去研究一下整形提升时的汇编代码。底层汇编指令实现的角度看，引用是类似指针的方式实现的。