引用及指针和引用的区别

一.在C语言中，我们要给函数传参，有两种方法。

1.传值

void Swap(int a,int b)
{
	int tmp=a;
	a=b;
	b=tmp;
}
int main()
{
	int a=10;
	int b=20;
	Swap(a,b);
	return 0;
}

优点：形参不影响实参（保护实参），可读性强。
缺点：不能通过形参改变实参,效率低（需要用实参拷贝形参）。
2.传地址

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

优点：可以通过形参改变外部的实参 效率高(不会创建副本)。
缺点 : 不安全，可读性差。

二.引用

C++为我们提供了新的一种传值方法—>传引用.

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

形式：类型& 引用变量名（对象名）=引用实体；

int main()
{
	int a = 10;
	int b = 30;
	int& ra = a;//类型& 引用变量名（对象名）=引用实体；
	cout << &ra << " = " << &a << endl;
	ra = 20;//a将被修改为20
	return 0;
}

注意：引用类型必须和引用实体是同种类型的。

引用特性

1. 引用在定义时必须初始化
2. 一个变量可以有多个引用
3. 引用一旦引用一个实体，再不能引用其他实体

 void TestRef()
{
	int a = 10;
	// int& ra; // 该条语句编译时会出错
	int& ra = a;
	int& rra = a;
	rra=20;//a,ra,rra都修改为20
	printf("%p %p %p\n", &a, &ra, &rra);
}

常引用

void TestConstRef()
{
	const int a = 10;
	//int& ra = a; // 该语句编译时会出错，a为常量
	const int& ra = a;
	// int& b = 10; // 该语句编译时会出错，b为常量
	const int& b = 10;
	double d = 12.34;
	//int& rd = d; // 该语句编译时会出错，类型不同
	const int& rd = d;//int和double可以进行隐式类型转换，编译器自己维护了一个空间，里面存的常量12，
	//我们不知道此空间的地址，也不知道此空间的名字，所以具有常属性，需要const类型的引用来引用。
}

引用的使用场景

1.可以做函数的形参

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

可以做到通过形参修改实参的值，而且不易出错，效率也高。

2.可以作为返回值的类型:只要返回的变量生命周期比函数长就行。

int& Add(int left, int right)
{
	int ret= left + right;
	return ret;
}
int main()
{
	int a = 10;
	int b = 20;
	int& retVal=Add(a, b);
	Add(100, 200);
	return 0;
}

运行结果如下：


错误的原因：第一次调用Add函数时，ret的值被修改为30，被返回引用，此时ret是栈上的空间，只是因为调用函数被临时开辟出来的，所以调用完之后空间被回收，ret中存的是垃圾值。第二次调用Add函数时，又需要开辟函数运行的空间，OS就把上次的空间给了出来，ret的值被修改为300，所以retVal被改为300。

结论：返回类型为引用时，不能返回栈上的空间。只要返回的变量生命周期比函数长就行。

传值、传指针和传引用效率比较

#include <time.h>
struct A
{
	int a[10000];
};
void TestFunc1(A a)
{}
void TestFunc2(A* a)
{}
void TestFunc3(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();
	// 以引用作为函数参数
	size_t begin3 = clock();
	for (size_t i = 0; i < 10000; ++i)
		TestFunc3(a);
	size_t end3 = clock();
	// 分别计算两个函数运行结束后的时间
		cout << "TestFunc1(int)-time:" << end1 - begin1 << endl;
		cout << "TestFunc2(int*)-time:" << end2 - begin2 << endl;
	cout << "TestFunc3(int&)-time:" << end3 - begin3 << endl;
}
// 运行多次，检测值，指针和引用在传参方面的效率区别
int main()
{
	for (int i = 0; i < 10; ++i)
	{
		TestRefAndValue();
	}
	return 0;
}

结论：传值最慢(需要拷贝一份实参的副本)，指针和引用效率差不多。

引用和指针的区别

在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。

int main()
{
	int a = 10;
	int& ra = a;
	cout<<"&a = "<<&a<<endl;
	cout<<"&ra = "<<&ra<<endl;
	return 0;
}

引用在底层就是按照指针类型来处理的。

//int a=10,b=20;
//int& ra = a;相当于int* const pa = &a;
//pa = &b;//错误
//const int& cra=a;相当于const int* const pa;

int main()
{
	int a = 10;
	int* pa = &a;
	int& ra = a;
	return 0;
}

反汇编代码是相同的。

引用和指针的不同点：

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

右值引用

传送门：https://www.cnblogs.com/likaiming/p/9045642.html