c++ 154 引用

#include<iostream>
using namespace std;
//引用作为函数参数不需要初始化
void myswap(int *a,int *b)
{
	int c = 0;
	c = *a;
	*a = *b;
	*b = c;
}
void main03()
{
	int a = 10;
	//引用语法 Type & name =var;
	int& b = a;
	b = 100;//相当于把a改成100；
	printf("b:%d\n", b);

	system("pause");
	return;
}
void main04()
{
	int x = 10;
	int y = 30;
	//a就是x的别名 b就是y的别名
	myswap(&x, &y);

	printf("x:%d,y:%d", x, y);
	system("pause");
	return;
}
//复杂数据类型做引用
struct Teacher
{
	char name[64];
	int age;

};
void printfT(Teacher* pT)
{
	cout << pT->age << endl;
}
void printfT2(Teacher &pT)
{
	cout << pT.age << endl;//注意是pT.
	pT.age = 33;
}
void printfT3(Teacher pt)//pt是元素 所以也是.
{
	cout << pt.age << endl;
	pt.age = 44;
}
void main()
{
	Teacher t1;
	t1.age = 56;
	 printfT(&t1);
	 printfT2(t1);//pT就是t1的别名
	 printf("t1.age:%d\n",t1.age);

	 printfT3(t1);//pt是形参 t1 copy一根树蕨给pT =t1 修改age的值并不会变化
	 printf("t1.age:%d\n", t1.age);
	 system("pause");
	printf("hello");
	return;
}

和指针占的内存是一样的

//引用的意义 本质:
void modifa(int& a1)
{
	a1 = 10;
}
void modifa2(int *const a1)//指针取地址
{
	*a1 = 200;
}
int main()
{
	int a = 10;
	modifa(a);//指向这个函数调用的时候 c++取地址了
	printf("a:%d\n", a);
	int& b = a;//b很像一个常量
	modifa2(&a);//如果是指针 则需要取实参的地址
	printf("a2:%d\n", a);
	printf("b:%d\n", b);
	//printf("&a:%d\n", &a);
	//printf("&b:%d\n", &b);///a 和 b均是同一块内存的门牌号

	//char* const p;//引用是一个常量指针
	cout << "hello" << endl;
	return 0;
}

//简介赋值 1.两个变量 一个是实参一个形参 2.建立关系 实参取地址赋值给形参 3.*p形参去间接修改实参的值
void modify3(int* p)
{
	*p = 200;//3.*P
}
void main()
{
	int a = 100;//1.实参
	int* p = NULL;//形参
	p = &a;//实参取地址赋值给实参 
	*p = 39;
	modify3(&a);//2. 建立关联
	return;
}
//1.不去想编译器怎么做
//2.站在编译器角度分析是否占内存

值放到寄存器里 然后又拷贝给a1；
返回引用本质是编译器帮我们返回地址

函数调用后是个乱码

void main08()
{
	int a1 = getA1();
	int a2 = getA2();
	int &a3 = getA2();//若返回栈区  不能作为初始值//函数返回一个内存空间 名字叫a3 打印指针指向的内存空间的数据

	//A2 临时变量 栈上分配内存 函数运行之后就被释放掉  
	printf("a1:%d a2:%d a3:%d", a1, a2, a3);
	
	return;
}

```cpp
//函数当左值 

//返回变量的值
int g1()
{
	static int a = 10;
	a++;
	return a;
}
//返回变量本身
int &g2()
{
	static int a = 10;
	a++;
	printf("a:%d\n", a);
	return a;
}
void main()
{//=100 错误
	g2() = 100; //a=100;  11
	g2();//101
	return;
}

//指针的引用
struct Teacher1
{
	char name[64];
	int age;
};
//在被调用函数 getTeacher 获取资源
  int getTeacher(Teacher1**p)
{
	Teacher1* tmp = NULL;
	tmp = (Teacher1*)malloc(sizeof(Teacher1));
	if (tmp == NULL)
	{
		return -2;
	}
	//p是实参的地址 *实参的地址间接修改实参的值
	tmp->age = 99;
	*p = tmp;
	
}
  //c++中
  struct Teacher2
  {
	  char name[64];
	  int age;
  };
  void getTeacher2(Teacher2*& myp)
  {
	  myp = new Teacher2;
	  if (myp == NULL)
	  {
		  cout << "Memory allocation failed" << endl;
		  return;
	  }
	  myp->age = 36;
  }
  void FreeTeacher(Teacher2*pT2)
  {
	  if (pT2 == NULL)
	  {
		  return;
	  }
	  free(pT2);
  }
int main()
{
	//c语言的二级
	Teacher1* pT1 = NULL; 
	getTeacher(&pT1);
	cout << "age:" << pT1->age << endl;
	//c++的引用(指针的引用)
	Teacher2* pT2 = NULL;
	getTeacher2(pT2);
	cout << "age:" << pT1->age << endl;
	FreeTeacher(pT2);
	system("pause");
	return 0;
}

//常量引用让实参变量拥有只读属性

#include<iostream>
using namespace std;

void main()
{

	//引用分为普通引用和常量引用
	//普通
	int a = 10;
	int& b= a;
	// 常引用
	int x = 30;
	const int& y = x;//常饮用是让变量引用只读属性  不能通过y去修改x
	//用字面量 初始化 常量引用
	const int c = 40;
	//int& m = 41;//普通引用 引用一个字面量 字面量没有内存地址
	//引用就是给多个门牌号取别名
	const int& m = 32;//给m分配内存空间
}