【C++】基础知识—引用和指针引用

￥···坚持每天写点东西，感觉很好，既复习基础知识，又可以收获成就感，何乐而不为呢？···￥

引用是C++引入的新语言的特性，是C++常用的内容之一，正确、灵活地使用引用，可以使程序简洁、高效。

一、引用简介

1. 变量名知识回顾

 变量名实质上是一段连续存储空间的别名，是一个标号(门牌号)； 程序中通过变量来申请并命名内存空间 ； 通过变量的名字可以使用存储空间

2. 引用就是某一已定义的变量（目标）的一个别名，对引用的操作与对变量直接操作完全一样。“reference”引用

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

例子：

int a; int &ra = a; // 定义引用ra,它是变量a的引用，即别名

说明：

1）&在此不是求地址运算，而是起标识作用。

2）类型标识符是指目标变量的类型。

3）声明引用时，必须同时对其进行初始化。

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

　 ra = 1; 等价于 a = 1;

5）声明一个引用，不是新定义了一个变量，它只表示该引用名是目标变量名的一个别名，它本身不是一种数据类型，因此引用本身不占存储单元，系统也不给引用分配存储单元。故：对引用求地址，就是对目标变量求地址。&ra与&a相等。

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

二、引用应用 （结合内存四区分析）

1. 引用做函数参数

引用的一个重要作用就是作为函数的参数。以前的C语言中函数参数传递是值传递，如果有大块数据作为参数传递的时候，采用的方案往往是指针，因为这样可以避免将整块数据全部压栈，可以提高程序效率。但是现在（C++）中有增加了一个同样有效率的方案（在一些特殊情况下又是必须的选择），就是引用。

例子：

void swap(int &p1, int &p2) //此处函数的形参p1, p2都是引用
{
   int p;
   p = p1;
   p1 = p2;
   p2 = p;
}

  为在程序中调用该函数，则相应的主调函数的调用点处，直接以变量作为实参进行调用即可，而不需要实参变量有任何的特殊要求。如：对应上面定义的swap函数，相应的主调函数可写为：

void main( )
{
　int a = 10;
  int b = 20;
　swap(a,b); // 直接以变量a和b作为实参调用swap函数
　cout << a <<  ' ' << b; //输出结果  20 10
} 

总结：

（1）传递引用给函数与传递指针的效果是一样的。这时，被调函数的形参就成为原来主调函数中的实参变量或对象的一个别名来使用，所以在被调函数中对形参变量的操作就是对其相应的目标对象（在主调函数中）的操作。

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

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

2. 常引用

常引用声明方式：

const 类型标识符 &引用名 = 目标变量名；

用这种方式声明的引用，不能通过引用对目标变量的值进行修改,从而使引用的目标成为const，达到了引用的安全性。

例子：

 int a ;
 const int &ra = a;
 ra = 1; // 错误
 a = 1; // 正确

1>常量引用初始化两种情况

   用变量初始化常引用；用字面量初始化常引用

void main()
{
	const int b = 10;
	printf("b:%d", &b);

	//int &a1 = 19; 如果不加const编译失败
	const int &a = 19;
	printf("&a:%d \n", &a);

	system("pause");
}

 2> 常引用总结

  1）Const &int e  相当于 const int * conste

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

  3）当使用常量（字面量）对const引用进行初始化时，C++编译器会为常量值分配空间，并将引用名作为这段空间的别名

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

3. 引用的本质

引用在C++中的内部实现是一个常指针。C++编译器在编译过程中使用常指针作为引用的内部实现，因此引用所占用的空间大小与指针相同。从使用的角度，引用会让人误会其只是一个别名，没有自己的存储空间。这是C++为了实用性而做出的细节隐藏。

案例：

struct Teacer {
	int &a;
	int &b;
};
int main()
{
	printf("sizeof(Teacher) %d\n", sizeof(Teacer));
	system("pause");
	return 0;
}

4. 引用作为返回值

 要以引用返回函数值，则函数定义时要按以下格式：

 类型标识符 &函数名（形参列表及类型说明）

 {   函数体  }

 说明：

1）以引用返回函数值，定义函数时需要在函数名前加&

2）用引用返回一个函数值的最大好处是，在内存中不产生被返回值的副本。

3） 若返回栈变量 -- 不能成为其它引用的初始值，不能作为左值使用              用内存四区分析

4）不能返回局部变量的引用。主要原因是局部变量会在函数返回后被销毁，因此被返回的引用就成为了"无所指"的引用，程序会进入未知状态。

5）不能返回函数内部new分配的内存的引用。虽然不存在局部变量的被动销毁问题，可对于这种情况（返回函数内部new分配内存的引用），又面临其它尴尬局面。例如，被函数返回的引用只是作为一 个临时变量出现，而没有被赋予一个实际的变量，那么这个引用所指向的空间（由new分配）就无法释放，造成memory leak。

6）可以返回类成员的引用，但最好是const。主要原因是当对象的属性是与某种业务规则（business rule）相关联的时候，其赋值常常与某些其它属性或者对象的状态有关，因此有必要将赋值操作封装在一个业务规则当中。如果其它对象可以获得该属性的非常 量引用（或指针），那么对该属性的单纯赋值就会破坏业务规则的完整性。

7）引用与一些操作符的重载：流操作符<<和>>，这两个操作符常常希望被连续使用，例如：cout << "hello" << endl;　因此这两个操作符的返回值应该是一个仍然支持这两个操作符的流引用。可选的其它方案包括：返回一个流对象和返回一个流对象指针。但是对于返回 一个流对象，程序必须重新（拷贝）构造一个新的流对象，也就是说，连续的两个<<操作符实际上是针对不同对象的！这无法让人接受。对于返回一 个流指针则不能连续使用<<操作符。因此，返回一个流对象引用是惟一选择。这个唯一选择很关键，它说明了引用的重要性以及无可替代性，也许这 就是C++语言中引入引用这个概念的原因吧。 赋值操作符=。这个操作符象流操作符一样，是可以连续使用的，例如：x = j = 10;或者(x=10)=100;赋值操作符的返回值必须是一个左值，以便可以被继续赋值。因此引用成了这个操作符的惟一返回值选择。

// 返回值是static变量，当引用
// 返回变量的值
int getB01()
{
	static int a = 10;
	a++;
	printf("a01: %d \n", a);
	return a;
}

// 返回变量的本身
int & getB02()
{
	static int a = 10;
	a++;
	printf("a02: %d \n", a);
	return a;
}
int *getB03()
{
	static int a = 10;
	a++;
	printf("a03: %d \n", a);
	return &a;
}
void main()
{

	int a1 = 10;
	int a2 = 20;
	a1 = getB01();
	a2 = getB02();
        int &a3 = getB02();

	printf("a1 = %d \n", a1);  // 11
        printf("a2 = %d \n", a2);  // 12
	printf("a3 = %d \n", a3);  // 12


	// getB01() = 100;
	/* 返回变量的值
	   相当于 11 = 100
	*/
	getB01();

        // 函数返回值是一个引用，并且当左值；也可以当右值
	getB02() = 100;
	getB02();

	*(getB03()) = 200;
	getB03();

	system("pause");
}

三、指针引用

 1）指针的引用是某一指针的别名，同变量的引用一样。引用绝对不是单独存在的，它一定是指示某个已经存在的东西的，它一定是某个已经存在的物体的“别名”

 2）如果被初始化赋值成某个变量后，它就始终是这个变量的替身。对引用的改变就是对这个变量的改变。

指向指针的引用的特殊点在于如下两点：

 1> 指向指针的引用，不仅改变了指针所指的对象，也改变了指针本身

[cpp]  view plain copy

1. int getF()  
2. {  
3.   
4.     int a = 1;  
5.     int b = 2;  
6.     int * temp = &a;  
7.     printf("temp01 = %d \n", *temp);      // 1  
8.     int *& p = temp;              // 指向指针的引用  
9.     p = &b;  
10.     printf("temp02 = %d \n", *temp);      // 2  
11.     *p = 5; // p指向的值改成了5，实际上是把b的值改变成了5.由于p是temp指针的引用，p指向的值改变了，自然temp指向的值也会改变  
12.   
13.     printf("a = %d \n", a);             // 1  
14.     printf("b = %d \n", b);             // 5  
15.     printf("temp03 = %d \n", *temp);    // 5  
16.     printf("p = %d \n", *p);            // 5  
17.     return 0;  
18. }  

[cpp]  view plain copy

1. int getS()  
2. {  
3.   
4.     int a = 1;  
5.     int b = 2;  
6.     int *temp = &a;  
7.     printf("temp01 = %d \n", *temp);      // 1  
8.     int *p = temp;                 // p指针变量，初始化的时候，与temp同指向a  
9.     p = &b;                        // p改变指向，指向b  
10.     printf("temp01 = %d \n", *temp);      // 1  
11.     *p = 5;                        // p指向的值，改变为5.实际上是把b的值改变为5，但temp指向的值没有发生改变，依然是5  
12.   
13.     printf("a = %d \n", a);             // 1  
14.     printf("b = %d \n", b);             // 5  
15.     printf("temp03 = %d \n", *temp);    // 1  
16.     printf("p = %d \n", *p);            // 5  
17.   
18.     return 0;  
19. }  

 2> 指向指针的引用，可以实现对传递给形参的实参数值的交换。即指向指针的引用可以修改指针的值，在参数传递时是地址

[cpp]  view plain copy

1. // 指向指针的引用是某一指针的别名，同变量的引用一样，可以实现对传递给形参给实参数值的交换  
2. void swapF(int *& a1, int *& a2)  
3. {  
4.     int *temp = a2;  
5.     a2 = a1;  
6.     a1 = temp;  
7.     printf("temp = %d \n", *temp);  
8.   
9. }  
10.   
11. // 利用指针进行数值交换，改变的只是形参的指向，实参的数值保持不变  
12. void swapS(int * a1, int * a2)  
13. {  
14.     // 指针交换数值，实际数值会改变  
15.     //int temp = *a2;  
16.     //*a2 = *a1;  
17.     //*a1 = temp;  
18.     //printf("temp = %d \n", temp);  
19.   
20.     int *temp = a2;  
21.     a2 = a1;  
22.     a1 = temp;  
23.     printf("temp = %d \n", *temp);  
24. }  
25.   
26. int main()  
27. {  
28.     int i = 10;  
29.     int j = 20;  
30.     int *pi = &i;  
31.     int *pj = &j;  
32.     printf("pi01 = %d \n", *pi);   // 10  
33.     printf("pj01 = %d \n", *pj);   // 20  
34.   
35.     swapF(pi, pj);  
36.     printf("pi02 = %d \n", *pi);   // 20  
37.     printf("pj02 = %d \n", *pj);   // 10  
38.     printf("i = %d \n", i);        // 10  
39.     printf("j = %d \n", j);        // 20  
40.   
41.   
42.     cout << endl;  
43.     cout << "案例2"<< endl;  
44.   
45.     int i2 = 10;  
46.     int j2 = 20;  
47.     int *pi2 = &i2;  
48.     int *pj2 = &j2;  
49.     printf("pi201 = %d \n", *pi2);   // 10  
50.     printf("pj201 = %d \n", *pj2);   // 20  
51.   
52.     swapS(pi2, pj2);  
53.     printf("pi202 = %d \n", *pi2);   // 20  
54.     printf("pj202 = %d \n", *pj2);   // 10  
55.     printf("i2 = %d \n", i2);        // 10  
56.     printf("j2 = %d \n", j2);        // 20  
57. } 

四、总结

1）在引用的使用中，单纯给某个变量取个别名是毫无意义的，引用的目的主要用于在函数参数传递中，解决大块数据或对象的传递效率和空间不如意的问题。

2）用引用传递函数的参数，能保证参数传递中不产生副本，提高传递的效率，且通过const的使用，保证了引用传递的安全性。

3）引用与指针的区别是，指针通过某个指针变量指向一个对象后，对它所指向的变量间接操作。程序中使用指针，程序的可读性差；而引用本身就是目标变量的别名，对引用的操作就是对目标变量的操作。

4）使用引用的时机。流操作符<<和>>、赋值操作符=的返回值、拷贝构造函数的参数、赋值操作符=的参数、其它情况都推荐使用引用。

案例：

#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++编译器帮我们程序员做了。
	// *p间接赋值成立条件：3个条件 
		// a)2个变量（通常一个实参，一个形参）
		// b) 建立关系，实参取地址赋给形参指针 
		// c) *p形参去间接修改实参的值 

	getTeacher2(pT1);

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

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