C++排雷：25.引用的理解（type * const name）

引用的用法

#include <iostream>
using namespace std;

//1 引用的概念 
//2 属于C++编译器对C的扩展,不能用c语言的语法去思考它
void main91()
{
	int  a = 10;

	//引用的语法：Type& name = var;
	int &b = a;

	b = 100; //相当于把a修改成100了.

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

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

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

void  main92()
{
	int a = 10;
	int &b = a;
	//int &c ; //03普通引用 必须要初始化
	system("pause");
}

//基础类型的引用 

void myswap(int a, int b)
{
	int c = 0;
	c = a;
	a = b;
	b = c;
}

void myswap02(int *a, int *b)
{
	int c = 0;
	c = *a;
	*a = *b;
	*b = c;
}

//04 引用作为函数参数声明时不进行初始化
void myswap03(int &a, int &b)
{
	int c = 0;
	c = a;
	a = b;
	b = c;
}
void  main93()
{
	int x, y ;
	x = 10;
	y = 20;

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

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

	//a就是x的别名  b就是y的别名
	myswap03(x, y);
	printf("x:%d , y:%d \n", x, y);

	//int &c ; //普通引用 必须要初始化
	system("pause");
}

//05复杂数据类型 的引用
struct Teacher
{
	char name[64];
	int age ;
};

void printfT(Teacher *pT)
{
	cout<<pT->age<<endl;
}

//pT是t1的别名 ,相当于修改了t1
void printfT2(Teacher &pT)
{
	//cout<<pT.age<<endl;
	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 ;
}

引用本质的思考

#include <iostream>
using namespace std;

//1 第一点 单独定义的引用时，必须初始化；说明很像一个常量
void main01()
{
	//
	 const  int c1 = 10;

	 int a = 10;
	 int &b = a;  //b很想一个常量

	 printf("&a:%d \n", &a);
	 printf("&b:%d \n", &b); //===> a 和 b就是同一块内存空间的门牌号
	cout<<"hello..."<<endl;
	system("pause");
	return ;
}

//2 普通引用有自己的空间吗？ 有 
struct Teacher
{
	char name[64]; //64
	int age; //4 

	int &a; //4 0  //很像指针 所占的内存空间大小
	int &b; //4 0 
};

//3 引用的本质

void modifyA(int &a1)
{
	a1 = 100;
}

void modifyA2(int * const a1)
{
	*a1 = 200;  //*实参的地址 ,去间接的修改实参的值 
}

void main1001()
{
	int a = 10;

	//1
	modifyA(a); //指向这个函数调用的时候,我们程序员不需要取a的地址
	printf("a:%d \n", a);

	//
	a = 10;
	modifyA2(&a); //如果是指针 需要我们程序员手工的取实参的地址 
	printf("a:%d \n", a); 

	printf("sizeof(Teacher):%d \n", sizeof(Teacher));
	system("pause");
}

void modifyA3(int *p)
{
	*p = 200;  //*p 3*p形参去间接修改实参的值
}
//间接赋值
void main()
{
	int a = 10;
	int *p = NULL; //间接赋值成立的三个条件 1 定义两个变量 

	p = &a;
	*p = 100;

	{
		*p = 200;
	}

	modifyA3(&a); //2 建立关联

}


// 123 写在一块
// 12   3
//1      23

常量引用

#include <iostream>
using namespace std;

//常引用的知识架构
void main1301() 
{
	//普通引用

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

	//常引用
	int  x = 20;
	const int &y = x;  //常引用 是 让变量 引用只读属性 不能通过y去修改x了
	//y = 21;

	//常引用 初始化 分为2种情况
	//1> 用变量 初始化 常引用
	{
		int x1 = 30;
		const int &y1 = x1; //用x1变量去初始化 常引用
	}
	//2> 用字面量 初始化 常量引用
	{
		const int a = 40;  //c++编译器把a放在符号表中
		int &m = 41; //普通引用 引用一个字面量 请问字面量有没有内存地址
		//引用 就是给内存取多个门牌号 (多个别名)
		//printf("&40:%d \n", &40);
		const int &m = 43;  //c++编译器 会 分配内存空间 
	}
	cout<<"hello..."<<endl;
	system("pause");
	return ;
}


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


//void printTeacher(const Teacher  * const myt)
void printTeacher(const Teacher &myt)
{
	//常引用 让 实参变量 拥有只读属性 
	//myt.age = 33;
	printf("myt.age:%d \n", myt.age);
	
}

void main()
{
	Teacher  t1;
	t1.age = 36;

	printTeacher(t1);

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