C++中的引用

引用就是某个目标变量的别名，对引用的操作与对变量的直接操作效果完全相同。

引用的声明方法：类型标识符 &引用名=目标变量名；

　　如下：定义引用ra，它是变量a的引用，即别名。

　　　　int a;

　　　　int &ra=a;

1）   声明一个引用，必须进行初始化。

2）引用声明完毕后，相当于目标变量有两个名称即该目标原名称和引用名，且不能再把该引用名作为其他变量名的别名。

3）引用本身不是一种数据类型，因此引用本身不占存储单元，系统也不会给引用分配存储单元。

4）不能建立数组的引用。因为数组是一个由若干个元素所组成的集合，所以无法建立一个数组的别名。

引用的本质是：  引用在C++中的内部实现是一个常量指针。

Type &name  < ==>  Type * const name  (即指针的值不能被修改)

将 “引用” 做函数参数有哪些特点？

1）传递引用给函数跟传递指针的效果是一样的。

2) 使用引用传递函数的参数，在内存中没有产生实参的副本，它是直接对实参的操作。 而使用一般变量传递函数的参数，当发生函数调用时，需要给形参分配存储单元，形参变量是实参变量的副本；如果传递是对象，还将调用拷贝构造函数。因此，在参数传递的数据较大时，用引用比用一般变量传递参数效率和所占空间都好。

3） 虽然用指针作为函数参数也能达到同样的效果。但是，在被调用函数中 同样要给形参分配存储单元，而且重复使用“*指针变量名”的形式进行操作，很容易产生错误且程序的阅读性较差，另一方面，在主调函数的调用点处，必须使用变量的地址作为实参。而引用更容易，更清晰。

函数返回值是引用（引用当左值）

1 当函数返回值为引用时

若返回的是栈变量，不能成为其他引用的初始值，不能作为左值使用。

<pre name="code" class="cpp"><span style="font-size:14px;">#include <iostream>
using namespace std;

int getAA1()
{
	int a ;
	a = 10;
	return a;
}

//返回a的本身 返回a的一个副本 10 
int& getAA2()
{
	int a ; //如果返回栈上的 引用, 有可能会有问题
	a = 10;
	return a;
}

int* getAA3()
{
	int a ;
	a = 10;
	return &a;
}

void main()
{
	int a1 = 0;
	int a2 = 0;
	a1 = getAA1();

	a2 = getAA2(); //10</span>

<span style="font-size:14px;">
</span>

<span style="font-size:14px;"></span><pre name="code" class="cpp"> //若返回栈变量<span style="color:#cc0000;">不能成为其它引用</span>的初始值，关键是看变量是不是被编译器回收了

int &a3 = getAA2();
printf("a1:%d \n", a1);printf("a2:%d \n", a2); printf("a3:%d \n", a3); // 相当于*a3 去读取值，可是此时局部变量已经被回收，因此是乱码cout<<"hello..."<<endl;system("pause");return ;}

2 若返回静态变量或全局变量

可以成为其他引用的初始值，即可作为左值使用，或者右值使用。

 指针的引用

指针的引用：引用是一个指针的类型。  

Type*   &name   可以用指针的引用，做函数参数 来实现  函数参数二级指针做输出的模型

 

#include "iostream"
using namespace std;

struct Teacher
{
	char name[64];
	int age ;
};

//在被调用函数 获取资源 
int getTeacher(Teacher **p)
{
	Teacher *tmp = NULL;
	if (p == NULL)
	{
		return -1;
	}
	tmp = (Teacher *)malloc(sizeof(Teacher));
	if (tmp == NULL)
	{
		return -2;
	}
	tmp->age = 33;
	// p是实参的地址  *实参的地址 去间接的修改实参的值
	*p = tmp; 
}


//指针的引用 做函数参数
int getTeacher2(Teacher* &myp)
{
	//给myp赋值 相当于给main函数中的pT1赋值
	myp = (Teacher *)malloc(sizeof(Teacher));
	if (myp == NULL)
	{
		return -1;
	}
	myp->age = 36;
}

void FreeTeacher(Teacher *pT1)
{
	if (pT1 == NULL)
	{
		return ;
	}
	free(pT1);
}

void main()
{
	Teacher *pT1 = NULL;

	//1 c语言中的二级指针
	getTeacher(&pT1);
	cout<<"age:"<<pT1->age<<endl;
	FreeTeacher(pT1);


	//2 c++中的引用 （指针的引用）
	//引用的本质 间接赋值后2个条件 让c++编译器帮我们程序员做了。
	getTeacher2(pT1);

	cout<<"age:"<<pT1->age<<endl;
	FreeTeacher(pT1);

	cout << "hello..." << endl;
	system("pause");
}

 常引用  

1 在C++中可以使用变量初始const引用

const Type & name  = var；

const 引用让变量拥有只读属性 

int a = 10;
const int &b = a;  //const 引用  使用变量a初始化

//int *p = (int *)&b;
b = 11; //err
//*p = 11; //只能用指针来改变了

2  使用字面量初始化 const引用  

//int &m = 10; //引用是内存空间的别名 字面量10没有内存空间 没有方法做引用
const int &m = 10; 

结论：

1） const & name  相当于 const int * const name；

2） 普通引用  相当于 int* const name;

3)  当使用常量（字面量）对const 引用进行初始化时，C++编译器会为常量分配空间，而字面量是放在代码区（没有内存空间），并把引用名作为这段空间的别名。

4）使用字面量对const引用初始化后，将生成一个只读变量。