C++特殊的“别名”引用

1 引用概念 引用概念

1）在C++中新增加了引用的概念
2）引用可以看作一个已定义变量的别名
3）引用的语法：Type& name = var;
4）引用做函数参数那?（引用作为函数参数声明时不进行初始化）

实例：

#include <stdio.h>
#include <stdlib.h>


int main(void) {
	int a = 666;
	float c = 10.0;

	int &b = a;
	float &d = c;

	//不能直接定义没有指向的别名
	int &e = a;

	printf("a = %d, b: %d\n", a, b);

	b = 888;
	printf("a = %d,  b: %d\n", a, b);

	printf("a 的地址：%p,  b 的地址：%p\n", &a, &b);

	system("pause");
	return 0;
}

2 引用是 C++的概念 的概念

属于C++编译器对C的扩展。

实例：

//问题：C中可以编译通过吗？
int main()
{
int a = 0;
int &b = a;
b = 11; //*b = 11;
return 0;
}
//结论：请不要用C的语法考虑 b=11

3 引用做函数参数 引用做函数参数

普通引用在声明时必须用其它的变量进行初始化，引用作为函数参数声明时不进行初始化。

实例：

#include <stdio.h>
#include <stdlib.h>

void swap(int a, int b) {
	int tmp = a;
	a = b;
	b = tmp;
}

//方式一，使用指针
void swaq1(int *a, int *b) {
	int tmp = *a;
	*a = *b;
	*b = tmp;
}

//方式二，使用引用
void swaq2(int &a, int &b) {
	//int &c;  //不可以
	int tmp = a;
	a = b;
	b = tmp;
}

int main(void) {
	int x = 10, y = 100;
	//swaq1(&x, &y);
	swaq2(x, y);

	printf("x: %d,  y: %d\n", x, y);

	system("pause");
	return 0;
}

4 引用的意义

1）引用作为其它变量的别名而存在，因此在一些场合可以代替指针。
2）引用相对于指针来说具有更好的可读性和实用性。

实例：

#include <stdio.h>
#include <stdlib.h>

int swap(int &a, int &b){
    int t = a;
    a = b;
    b = t;
    return 0;
}
int swap(int *a, int *b){
    int t = *a;
    *a = *b;
    *b = t;
    return 0;
} 

5 引用本质思考

思考1：C++编译器背后做了什么工作？

实例：

#include <stdio.h>
#include <stdlib.h>

/*int swap1(int &a, int &b) {
	int t = a;
	a = b;
	b = t;
	return 0;
}*/

int swap2(int * const _a, int *const _b) {
	int t = *_a;
	*_a = *_b;
	*_b = t;
	return 0;
}

int main(void) {
	int x = 10;
	int &y = x;
	int z = 1000;
	int w = 10000;

	y = z;	//y是没有办法指向z

	printf("x: %d  y: %d  z: %d w: %d \n", &x, &y, &z, &w);

	//int &b = a;
	//b是a的别名，请问C++编译器后面做了什么工作？


	//1. 请思考：对同一内存空间可以取好几个名字吗？
	//int &c = a;
	//int &d = a;

	//printf("a: %d  b: %d  c: %d  d: %d\n", a, b, c, d);
	//2. 引用有没有自己的空间


	//结论：引用可以定义多个，引用有自己的空间，那么，引用像什么？
	//综上几点分析：别名很想常指针
	//int &b = a;		int * const b = &a;
	//swaq1(z, w);	换成	swaq2(&z, &w);  

	swap2(&z, &w);

	printf("z: %d, w: %d \n", z, w);

	system("pause");
	return 0;
} 

6 引用的本质 引用的本质

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

实例：

#include <stdio.h>
#include <stdlib.h>

void func(int &var){
    var = 15;
}

void func(int *const var){
    *var = 15;
}

int main(void){
    int value= 10;
    func(value);
    
    system("pause");
    return 0;
}

7 引用结论 引用结论

1)当实参传给形参引用的时候，只不过是c++编译器帮我们程序员手工取了一个实参地址，传给了形参引用（常量指针）。
2)当我们 使用引用语法的时，我们不去关心编译器引用是怎么做的当我们 分析奇怪的语法现象的时，我们才去考虑c++编译器是怎么做的。

8 指针引用

实例：

#include <stdio.h>
#include <stdlib.h>

void boy_home(int **meipo) {
	static int boy = 23;
	*meipo = &boy;
}

void boy_home1(int* &meipo) {
	static int boy = 23;
	meipo = &boy;
}

int main(void) {
	/*int x = 666;
	int *p = &x;

	int* &q = p;		//定义指针变量的引用

	printf("*p: %d  *q: %d\n", *p, *q);*/

	int *meipo = NULL;
	//boy_home(&meipo);
	boy_home1(meipo);
	printf("boy: %d\n", *meipo);

	system("pause");
	return 0;
}

9 常引用 常引用

在 C++中可以声明 const 引用
语法： const Type& name = var；
const 引用让变量拥有只读属性
分两种情况：

1. 用变量初始化常引用
2. 用字面量初始化常量引用

实例：

#include <stdio.h>
#include <stdlib.h>

int main(void) {
	int a = 10;
	//int &b =a;
	//1. 用变量初始化常引用。
	const int &b = a;

	//b = 100;	//常引用是让变量引用变成只读，不能通过引用对变量进行修改。
	printf("a: %d\n", a);

	//2. 用字面量初始化常量引用。
	const int c1 = 10;
	const int &c2 = 10;//这个是在C++中，编译器会对这样的定义的引用分配内存，这算是一个特例。
	int c3 = c2;

	//c2 = 100;
	system("pause");
	return 0;
}

const 引用结论：

1）const & int e 相当于 const int * const e
2）普通引用 相当于 int *const e1
3）当使用常量（字面量）对const引用进行初始化时，C++编译器会为常量值分配空间，并将引用名作为这段空间的别名。
4）使用字面量对const引用初始化后，将生成一个只读变量

这是我第一次写博客效果可能不是很好，但是我以后会加油的。
以上是上课时做的笔记，我个人认为写的还不错所以才发布的。