02.c++中的引用详解

一、普通引用

1.引用的概念

1. 当使用引用的时候，我们可以单纯的把引用理解为对一个已经定义的变量(常量)起一个别名。
2. 引用的语法:Type& name = var，引用在声明时必须初始化，原因如3.
3. 引用的本质是一个常指针，指向变量，所以引用占用4个字节，如下所示

int var;
Type& name = var;    <==>      Type *const name = &var;

在使用引用name时，编译器自动将name解释成*name

void func(int &a)		<==>				void func(int *const a)
{											{
	a = 5;										*a=5;
}											} 

struct Teacher{
	char name[32];	//32
	int age;		//4
	int &a;			//4
};
sizeof(Teacher) = 40

4. 对引用取地址，就相当于对引用指向的变量取地址

	int a;
	int &b = a;
	cout << &b << endl << &a << endl;	//这两个输出的是同一个地址

2.引用做函数参数

struct Teacher{
	char name[32];	//32
	int age;		//4
};
void printfT(Teacher &T)
{
	cout << T.age << endl;
	T.age = 14;	//这里修改，上层也会修改，因为这里相当于传入的是指针
}

3.函数返回值是引用时
第一种情况：

int& getAA1()
{
	int a = 5;
	return a;	//返回a的引用
}
int main(int argc, char* argv[])
{
	int var = getAA1();		//这里var = a的引用，相当于var = a
	int& var1 = getAA1();	//这里的var1是一个引用，=a的引用，要是输出a的话，还是要具体看a的内存空间还在不在
	
	cout << var << endl;	//5
	cout << var1 << endl;	//debug下是乱码，release下是5
	return 0;
}

如上注释，debug下是乱码，release下是正确的，我的理解是，debug下并不会对代码进行优化，而getAA1函数执行完后，里面的变量就会从栈中释放掉。而release会对代码进行优化，它发现主函数调用时用的是引用，所以会把栈中的值赋给它。

第二种情况，返回的引用做左值时：

int& j1()
{
	static int a = 10;
	a++;
	printf("a:%d \n", a);
	return a;
}

void main()
{
	j1() = 20;		//a: 11
	j1();			//a: 21
}

第一次执行j1()时，输出a=11，返回a的引用，a的引用 = 20，相当于a=20，而a在静态存储区，所以a不被释放，这时a的值就改成了20，第二次执行时，20++，输出结果是21.

4.指针的引用

Type  *p;
Type*  &name = p;

struct Teacher{
	char name[64];
	int age;
};
/* 这两个函数的实现是一样的 */
void getT(Teacher * &myp)
{
	myp = (Teacher *)malloc(sizeof(Teacher));
	myp->age = 34;
}

void getT2(Techer **myp)
{
	*myp = (Teacher *)malloc(sizeof(Teacher));
	(*myp)->age = 34;
}

int main()
{
	Teacher *p;
	getT(p);	
	getT2(&p);	
}

二、常引用:让变量拥有只读的属性

1.使用变量初始化const引用

const Type& name = var；
相当于
const Type *const name = &var;	
不可以通过指针更改var的值，并且不能更改指针的指向

int main()
{
	int a=10;
	const int &b = a;
	
	cout << b << endl;	//通过引用b来访问a当然没问题
	b = 10;				//err，通过引用b来修改a的值就不行
}

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

const int a = 10;
int &b = a;				//出错，a是常量，不可以建立引用
const int &b = a;		//正确，这样会在内存中开辟一块内存，来存储常量10
int &c = 41;			//错误，不能对一个数建立引用，因为这个数在内存中没有存储空间
const int &c = 41;		//正确，给常量建立常引用时，会在内存中开辟一块空间来存储41.