【C++】C & C++引用(三)

1. 概念

在c++中包含两种引用，分别是“普通引用”与“常量引用”，那么什么是引用？引用就是为对象起了另外一个名字，引用类型引用另外-一种类型，我们可以理解为引用即是别名。通常写成&d的形式。首先要明白引用 ！= 复制、拷贝，它是与初始值绑定到一起。可以这样理解引用就是给一个对象取别名，一个对象可以有多个别名，但取的别名也只能对应这个开始初始化的对象，中途不能作为另一对象的别名，引用本身不是对象。

2. 普通引用

2.1 基础概念
1）对一段连续的内存空间只能取一个别名吗？不是
2）引用是C++的概念，不要用c语言去考虑
3）引用可以看作一个已定义变量的别名
4）引用的语法：Type& name = var；具体如下所示：

int i = -1,&r = i;    //引用必须初始化，正确
int &t    //报错，没有初始化
int &c = 4;    //报错，错误初始化
r = 2;     //通过引用改变对象的值
int j = 3, &r = j;  //错误引用，多次初始化
double i = 2;
int &rename = i;   //错误，类型不匹配

其中关于 【常引用】 的初始化后面在详说

2.2 引用做函数参数
1）普通引用在声明时必须用其它的变量进行初始化
2）引用作为函数参数声明时不进行初始化

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

//pT是t1的别名 ,相当于修改了t1
void printfT2(Teacher &pT)
{
	pT.age = 33;
}

//pT和t1的是两个不同的变量
void printfT3(Teacher pT)
{
	cout<<pT.age<<endl;
	pT.age = 45; //只会修改pT变量 ,不会修改t1变量
}

void main()
{
	Teacher t1;
	t1.age = 35;
	printfT(&t1);
	printfT2(t1); //pT是t1的别名
	printf("t1.age:%d \n", t1.age); //33
	printfT3(t1) ;// pT是形参 ,t1 copy一份数据 给pT //---> pT = t1
	printf("t1.age:%d \n", t1.age); //35
	cout<<"hello..."<<endl;
	system("pause");
	return ;
}

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

2.4 引用本质思考
1）思考1：C++编译器背后做了什么工作？
2）请思考：对同一内存空间可以取好几个名字吗？

int main()
{
int a = 10;
int &b = a;
//b是a的别名，请问c++编译器后面做了什么工作？
b = 11;
cout<<"b--->"<<a<<endl;
printf("a:%d\n", a);
printf("b:%d\n", b);
printf("&a:%d\n", &a);
printf("&b:%d\n", &b); //请思考：对同一内存空间可以取好几个名字吗？
system("pause");
return 0;
}

输出结果：
b--->11
a:11
b:11
&a:9697788
&b:9697788
请按任意键继续. . .

可以看到a、b的地址是相同的，这就表明对于同一空间可以有多个别名。单独定义的引用时，必须初始化；说明很像一个常量

3）思考2：普通引用有自己的空间吗？ 有

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

输出结果：
sizeof(Teacher) 8
请按任意键继续. . .

double的时候sizeof(Teacher) 8
请按任意键继续. . .

【可以看到 这些引用很像指针，所占内存空间大小为4字节】

2.5 结论

1）引用在C++中的内部实现是一个常指针 Type& name 》》Type *const name
2）C++编译器在编译过程中使用常指针作为引用的内部实现，因此引用所占用的空间大小与指针相同。
3）从使用的角度，引用会让人误会其只是一个别名，没有自己的存储空间。这是C++为了实用性而做出的细节隐藏
4）引用在实现上，不过是把：间接赋值成立的三个条件的后两步和二为一,当实参传给形参引用的时候，只不过是c++编译器帮我们程序员手工取了一个实参地址，传给了形参引用（常量指针）
5）当我们使用引用语法的时，我们不去关心编译器引用是怎么做的,当我们分析奇怪的语法现象的时，我们才去考虑c++编译器是怎么做的

间接赋值成立的三个条件：
1）定义两个变量 （一个实参一个形参）
2）建立关联 实参取地址传给形参
3）*p形参去间接的修改实参的值

2.6 函数返回值是引用(引用当左值)
C++引用使用时的难点：
当函数返回值为引用时，若返回栈变量，不能成为其它引用的初始值 ，不能作为左值使用。
若返回静态变量或全局变量，可以成为其他引用的初始值，即可作为右值使用，也可作为左值使用。
1）C++链式编程中，经常用到引用，运算符重载专题
2）返回值是基础类型，当引用

返回的是变量的“值”
int getAA1()
{
	int a;
	a = 10;
	return a;
}

返回变量本身a,包括地址，值
int& getAA2()
{
int a;
a = 10;
return a;
}

返回变量地址
int* getAA3()
{
int a;
a = 10;
return &a;
}
int main()
{
	int a1 = getAA2();
	int &a2 = getAA2();
	int *a3 = getAA3();
	printf("a1=%d\n", a1);	//直接接受内存空间的值10
	printf("a2=%d\n", a2);  //指向内存空间的值，随机
	printf("a3=%d\n", a3);  //指向内存空间的地址
	system("pause");
	return 0;  }
输出结果：
a1=10
a2=-2
请按任意键继续. . .

为什么?
这是由于引用作为函数返回值，C++编译器会自动的帮我们给变量a取地址，&a,此时返回的是一个内存空间地址，但重要是我们不能机械的认为函数返回的是一个地址，这取决于函数外怎么来接收这个值，若用一个变量a1接，那么a1就会接到这个地址中的value；若是用引用a2来接，且又引用本质是一个指针，这个指针就会指向变量a的地址，当在打印的时候，C++编译器会暗地自动的对a进行 *a 操作，最后打印出该地址中的值，但是此时调用的函数getAA2()早已经被释放，地址中存储的a=10值也被清除，因此输出的值是一个随机的数。
a、 简而言之 ，当函数返回值为引用时，若返回栈变量，不能成为其它引用的初始值 ，不能作为左值使用
b、引用当作函数返回值可以视为返回变量本身

3) 返回值是static变量，当引用

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

int main()
{
	int a1 = j1();
	int &a2 = j1();
	j1() = 14;
	printf("a1=%d\n", a1);	
	printf("a2=%d\n", a2);  
	system("pause");
	return 0;  }
结果：
a1=11
a2=12    //这是由于静态变量的每次加加1
请按任意键继续. . .

若返回静态变量或全局变量，可以成为其他引用的初始值，即可作为右值使用，也可作为左值使用

4）返回值是形参，当引用

int& g2(int *p) //
{
*p = 100;
return *p;
}
int main()
{
	int b = 2;
	int &a2 = g2(&b);
	printf("a2=%d\n", a2+1);
	system("pause");
	return 0;
结果：
a2=101
请按任意键继续. . .
}

用引用去接受函数的返回值，是不是乱码，关键是看返回的内存空间是不是被编译器回收了。

5）返回值非基础类型
1）如果返回引用不是基础类型，是一个类，那么情况非常赋值。。涉及到copy构造函数和=操作重载，后面在讲**【比较复杂+特殊】**

2.7 指针引用
1）指针的引用而已
2）**p => *&p

3. 常引用

在C++中可以声明const引用，const Type& name = var；const引用让变量拥有只读属性

3.1 常引用的初始化

int main()
{
int a = 10;
const int &b = a; 
【常引用 作用是让变量、引用有只读属性，不能通过b修改a的值，按仍然可以通过a改变值a=9】
}

3.2 使用字面量常量初始化const引用

const int &a = 19; int &a1 = 10; //如果不加const编译失败，引用是内存空间的别名 字面量10没有内存空间 没有方法做引用
3.3 常引用的空间分配
1）用变量对const引用初始化，const引用分配内存空间了吗？
2）用常量对const引用初始化，const引用分配内存空间了吗？

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