2.C++“引用”

一、定义

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

图中的方框为变量a在内存中开辟的空间，ra和rra也都指向此空间 

void TestRef()
{
 int a = 10;
 int& ra = a;//<=定义引用类型，ra为a的别名
 
 printf("%p\n", &a);
 printf("%p\n", &ra);
}

---

二、引用特性

1. 引用在定义时必须初始化

2.一个变量可以有多个引用

3. 引用一旦引用一个实体，再不能引用其他实体

4. 引用类型必须和引用实体是同种类型的

void TestRef()
{
 int a = 10;
 int b = 20;
 // int& ra; //报错，引用在定义时必须初始化
 int& ra = a;
 int& rra = a;  //ra，rra都是变量a的引用
 int& rra = b;  //rra不能在当b的引用
 double& rb = b;  //b是int，rb是double，报错
}

int main()
{
    int a = 1;
    int& c = a;
    int d = 2;
    c = d;  //此处c是变成了d的引用？（错误）or将d=2的值赋给c（正确）
}

---

三、常引用

总结：变量访问的权限可以缩小，不能放大

注意：变量赋值之间没有权限缩小还是放大，引用、指针才有

//权限放大和缩小规则，适用于引用和指针
int main()
{
    //1.权限放大，const不能给非const，const只能给const
    const int a = 0;
    int& b = a;  //a是只读，b的类型是int，就是可读可写的。编译错误
    const int& b = a;   //编译通过
    //2.权限缩小，非const既可以给非const，也可以给const
    int c = 1;
    const int& e = c;  //可以，c是可读可写，e变成别名只读
	//3.指针
	const int* cp1 = &a;
	int* p1 = cp1;  //编译错误，属于权限放大

	int* p2 = &c;
	const int* cp2 = p2;   //可以，属于权限缩小
    return 0;
}

 int i = 0;
 double db = i;    //类型转换 
 double& rb = i;   //编译错误
 const double& rb = i;   //编译成功

int型i转为double型db，是创建了一个double的临时变量交给db，而临时变量具有常性（const），只能是可读的，所以要加const。

---

四、引用做参数和返回值

        以值作为参数或者返回值类型，在传参和返回期间，函数不会直接传递实参或者将变量本身直接返回，而是传递实参或者返回变量的一份临时的拷贝，因此用值作为参数或者返回值类型，效率是非常低下的，尤其是 当参数或者返回值类型非常大时，效率就更低。

1.引用做参数

void swap_cpp(int& r1,int& r2)
{      //传参过程：int& r1 = a，int& r2 = b，将a，b的别名传入函数
	int tmp = r1;
	r1 = r2;
	r1 = tmp;
}
int main()
{
	int a = 0, b = 1;
	swap_cpp(a,b);
}

swap：是将主函数中的变量a=0和b=1的拷贝传给swap函数；

swap_cpp:传递的是a和b的引用，直接对主函数中a和b进行操作

2.引用做返回值

int count1()
{
	static int n = 0;
	n++;
	return n;
}
int& count2()     //直接返回n，不是创建临时变量返回
{
	static int n = 0;
	n++;
	return n;
}
int main()
{
	const int& r1 = count1();//count1中返回的是临时变量n，临时变量都具有常性（只可读），所以加const
	int& r2 = count2(); //r2为count2中变量n的别名
	return 0;
}

count1中return n 又额外创建了一个空间 ；count2返回的就是函数中的n，没有额外创建空间

---

 五、不安全引用

总结:一个函数要使用引用返回，返回变量出了这个函数的作用域还存在，就可以使用引用返回，否则就不安全。（全局、静态变量）

int& add2(int a,int b)
{
	int c = a + b;
	return c;
}
int main()
{
	int& ret = add2(1,2);
    //add2(3,4);
	cout << "add2(1,2) is :" << ret << endl;
	return 0;
}
//输出：-858993460（随机值）

执行完add2（1，2）后，add2空间使用权不归add2所属，可能被其他程序占用，c的值会发生变化，ret又是c的别名，所以打印ret的值可能会是随机值。

//这里的输出与所用的编辑器有关，有的会显示3。这里的add2(1,2)运行完，所在空间控制权被其他程序占用（例子中可能是被cout占用），会改变了c的值，进而改变ret的值。

 未运行cout时ret的值为3

运行完cout时ret的值为-858993460

取消 add2（3，4）的注释仍无法打印；但是这里用printf打印没有问题

---

加static 

int& add2(int a,int b)
{
	static int c = a + b;
	return c;
}
int main()
{
	int& ret = add2(1,2);
	cout << "add2(1,2) is :" << ret << endl;
	return 0;
}

加上static后，c的值就存入静态区数据段中，add2函数执行完后，c的值不会发生变化

---

int& add2(int a,int b)
{
	static int c = a + b;
	return c;
}
int main()
{
	int& ret = add2(1,2);
	add2(3,4);
	cout << "add2(1,2) is :" << ret << endl;
	return 0;
}
//输出：3

执行add（1，2）的时候第一次执行static int c = a + b;将c的值赋成3保存在数据段中。再调用add（3，4）不会执行static int c = a + b，此语句只会在第一次初始化时执行，之后不会执行，所以c的值不变。

int& add2(int a,int b)
{
	static int c = 1;
	c = a + b;
	return c;
}
int main()
{
	int& ret = add2(1,2);
	add2(3,4);
	cout << "add2(1,2) is :" << ret << endl;
	return 0;
}
输出：7

执行add（1，2）的时候第一次执行static int c = 1;将c的值赋成1保存在数据段中。c = a + b，c的值变为3，并定义ret为c的别名；再调用add（3，4），c = a + b，c的值变为7，ret的值也为7

---

六、引用和指针的区别 

1.在语法概念上引用就是一个别名，没有独立空间，和其引用实体共用同一块空间。在底层实现上实际是有空间的，因为引用是按照指针方式来实现的。

int main()
{
    int a = 10;
    int& b = a;
    int* p = &a;
    return 0;
}

2.引用和指针的不同点

1. 引用在定义时必须初始化，指针没有要求

2. 引用在初始化时引用一个实体后，就不能再引用其他实体，而指针可以在任何时候指向任何一个同类型实体

3. 没有NULL引用，但有NULL指针

4. 在sizeof中含义不同：引用结果为引用类型的大小，但指针始终是地址空间所占字节个数(32位平台下占 4个字节)

5. 引用自加即引用的实体增加1，指针自加即指针向后偏移一个类型的大小

6. 有多级指针，但是没有多级引用

7. 访问实体方式不同，指针需要显式解引用，引用编译器自己处理

8. 引用比指针使用起来相对更安全