@[TOC]

引用

概念

引用是给已经存在的变量取一个别名，它和它引用的变量公用一块空间。就像李逵和黑旋风一样，是同一个人。
引用的符号是&，和取地址符号是一样的。

int a = 10;
	int& ra = a;
	printf("%d %p\n", a, &a);
	printf("%d %p\n", ra, &ra);

这段代码定义了一个ra作为已存在变量a的引用。
它们的值和地址时一样的。

引用的特性

引用在定义时必须初始化

int a=10;
int &b;//错误，没有初始化
int &b=a;//正确，进行了初始化

引用类型必须和引用对象是同种类型的

int a=10;
int& ra=a;//正确，同种类型
double& rra=a;//错误，不同种类型

引用和原变量的变化是同时的

由于引用和原变量的地址时相同的，它们本质上是同一个变量，所以两者的变化是同时变化：

int a = 10;
	int& ra = a;
	ra = 20;
	printf("%d", a);

改变的是a的引用ra的值，但是a的值也发生了变化。

一个变量可以有多个引用

int a = 10;
	int& ra = a;
	ra = 20;
	int& b = ra;
	int& c = b;
	c = 90;
	printf("%d", a);

这里ra是a的引用，b是ra的引用，c是b的引用，它们都占用同一块内存空间，所以他们都是a的引用，改变其中一个值，所有变量的值都会发生改变。

注意事项1

注意和赋值语句区分

int a = 10;
	int& ra = a;
	int c = 20;
	c = ra;//赋值语句，改变c不改变a的值
	c = 15;
	printf("%d", a);

注意事项2

小号不能是别人的大号，会报错

int a = 10;
	int b = 20;
	int& b = a;

这段代码就是错误代码，a的小号不能取名为b。因为b已经是一个存在的变量了。

常引用

常引用即为带const修饰的引用。

权限放大是不允许的

const int a=10;
int& ra=a;

a为常量，而ra是变量，这样定义ra是不被允许的。

权限缩小是允许的

int a=20;
const int& ra=a;

这样写相当于把一个变量a变成了常量，是被允许的。这样写的目的是，只能通过修改a的值来修改ra的值。而不能直接对ra进行赋值操作。
通常如果涉及到常引用，变量与引用是保持一致的。

常引用的注意事项

来看这样一段代码：

    int c = d;//可以
	int& c = d;//不行
	const int& c = d;//可以

第一行是被允许的，会发生整型截断。
第二行是不可以的，因为当进行隐式类型转换的时候，会创建临时变量去接收d的值，然后对临时变量进行截断，然后再将临时变量赋值给c。临时变量是右值，此时c应该为临时变量的别名，类型应为const int所以这样写不行。
第三行将c的类型改为与临时变量相同的类型const int，就可以编译通过。

补充：表达式运算也会出现临时变量
所以int& ret=x1+x2是错误的，应该改写为const int& ret=x1+x2。

结论

1.const Type& 可以接收各种类型的对象。
2.使用引用传参，如果函数中不改变引用的值，建议使用const引用。

引用的应用

作参数

引用作参数可以达到指针作参数的效果，可以对比一下这两段代码：

void Swap(int* a, int* b)
{
	int tmp = *a;
	*a = *b;
	*b = tmp;
}
int main()
{
	int a = 10;
	int b = 20;
	Swap(&a, &b);
	cout << a << " " << b << endl;
	return 0;
}

我们都知道，在进行交换两个数时，向Swap函数中传递的一定是两个数的地址，不能传递数本身。这是由于形参是实参的拷贝，改变形参并不能改变实参。
但是如果使用引用来作为参数，就可以达到修改实参的目的，因为引用与原变量占用同一块空间。

void Swap(int& a, int& b)
{
	int tmp = a;
	a = b;
	b = tmp;
}
int main()
{
	int a = 10;
	int b = 20;
	Swap(a, b);
	cout << a << " " << b << endl;
	return 0;
}

这里的形参实际上就是实参，改变形参，实参也会跟着改变。

可以使用引用传参的方法来避免使用指针。
注意传值与传引用会构成函数重载，但是在使用时会报错，这是因为调用不明确。举一个栗子：

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 a = 10;
	int b = 20;
	Swap(a, b);
	cout << a << " " << b << endl;
	return 0;
}

作返回值

返回值的拷贝

在学习引用作为返回值之前，我们需要了解返回值是怎么来的。

int Add(int a, int b)
{
	return a + b;
}
int main()
{
	int a = 10;
	int b = 20;
	printf("%d", Add(a, b));
}

这是一段很简单的程序，我们知道形参是实参的拷贝（不使用引用的情况下），其实返回值也有自己的拷贝，返回的并不是a+b的值本身，而是a+b的值的拷贝。
这是因为如果返回的是a+b值本身的话，那么在打印Add(a,b)的值之前，Add(a,b)已经执行结束了，这意味着形参a和b已经被销毁了，其实无法返回a+b的值了已经。
那么返回值的拷贝存放在哪里呢？
1.当返回值比较小时，一般存放在寄存器中。
2.当返回值较大时，一般存储在调用带有返回值的函数的栈帧中。

引用作返回值

int& Add(int a, int b)
{
	int c= a + b;
	return c;
}
int main()
{
	int a = 10;
	int b = 20;
	int& ret = Add(a, b);
	printf("%d", ret);
}

这样写是不正确的，虽然编译器不会报错，但是其实返回值c并没有拷贝新的空间，返回的就是c本身，然而c在函数结束时已经销毁了，如果在打印之前调用一个函数，将原来放置c的空间进行覆盖，打印的就不是30了。

因此如果函数返回时，出了函数作用域，如果返回对象还未还给系统，则可以使用引用返回，如果已经还给系统了，则必须传值返回。

struct A { int a[10]; };
A a;
A& Test1() { return a; };
int main()
{
	A b = Test1();
}

void Swap(int& a, int& b)
{
	int tmp = a;
	a = b;
	b = tmp;
}
int main()
{
	int a = 10;
	int b = 20;
	Swap(a, b);
	cout << a << " " << b << endl;
	return 0;
}

int& At(int i)
{
	static int a[10];
	return a[i];
}
int main()
{
	int i;
	for (i = 0; i < 10; i++)
	{
		At(i) = i;
	}
	for (i = 0; i < 10; i++)
	{
		cout << At(i) << endl;
	}
	return 0;
}

int a = 1;
	int& b = a;
	int* p = &a;

int Add(int a, int b)
{
	int c = a + b;
	return c;
}
int main()
{
	int a = 10, b = 20;
	int c = Add(a, b);
	cout << c;
}

inline int Add(int a, int b)
{
	int c = a + b;
	return c;
}
int main()
{
	int a = 10, b = 20;
	int c = Add(a, b);
	cout << c;
}

auto int a=0;

    int a = 0;
	auto b = a;//自动推导出b为int
	auto c = 10;//自动推导出c为int
	auto d = 1.1;//自动推导出d为double

int a=0;
auto p1=&a;
auto* p2=&a;

auto a=10,b=20;
auto c=10,b=2.3;

void Test(auto a);

int a[]={1,2,3};//正确
auto b[]={4,5,6};//错误

int arr0[] = { 1,2,3,4,5,6,7,8,9,0 };
	for (auto e : arr0)
	{
		cout << e <<endl;
	}

for (auto& e : arr0)
	{
		e++;
	}

void Test(int* arr)
{
	for (auto e : arr)
	{
		cout << e;
	}
}
int main()
{
	int arr0[] = { 1,2,3,4,5,6,7,8,9,0 };
	Test(arr0);
}

void f(int)
{
	cout << "f(int)" << endl;
}
void f(int*)
{
	cout << "f(int*)" << endl;
}
int main()
{
	f(NULL);
	f(nullptr);
}