2021-09-13 引用

• new操作符
  如
  int * p = new int(10);
  delete p;
  在此创建的数据在堆区，并且需要程序员自己释放 delete p;

• 引用
  给一个变量起个别名
  int a = 10;
  int &b = a; //即让b也表示 和a同地址的变量 引用操作
  b = 20;
  cout << a << endl; //修改b的值 输出a也会被修改 因为a,b表示的都是同一个变量为20

• 注意：
  1.引用必须初始化 ， 不能单纯 int &b ;
  2.初始化后不可改变（不可换成别的变量比如int c = 50 ; int &b = c;）
  但是可以赋值 c = b;

• 引用做函数参数
  通过引用，让形参来修饰实参
  值传递中 形参是不能修饰实参的 但是地址传递可以，引用传递同样也能完成。

//值传递
void mySwap01(int a, int b)
{
	int temp = a;
	a = b;
	b = temp;
	cout << "mySwap01a =" << a << endl;
	cout << "mySwap01b = " << b << endl;
}
//地址传递
void mySwap02(int *a,int *b)
{
	int temp = *a;
	*a = *b;
	*b = temp;
}
//引用传递
void mySwap03(int &a, int &b)  
// &符号表示为引用  这样接收 Swap03中的int &a的a  就是实参a的别名 
{                              //   只不过 名字都是a  
	int temp = a;
	a = b;
	b = temp;
}
int main()
{
	int a = 10;
	int b = 20;
	mySwap01(a, b);
	mySwap02(&a, &b);  //地址传递 形参会修饰实参 
	mySwap03(a,b);  // 引用传递  形参也会修饰实参
	cout <<"a ="<< a << endl;
	cout << "b = "<<b << endl;
		system("pause");
    	return 0;
}

• 引用可做函数返回值

int& test01()
{
	 int a = 10; //局部变量 存放在栈区 
	 return a;
}
int main()
{
//引用做函数的返回值
	int& ref = test01();
	cout << "ref=" << ref << endl; //第一次输出正确 编译器有所保留
	cout << "ref=" << ref << endl; //第二次乱码 a的内存编译器已经释放
		system("pause");
    	return 0;
}

第一次编译器做有保留
第二次已经释放，所以不为 10

所以不要返回局部变量的引用

2.函数的调用可以作为左值

//函数的调用可以作为左值
int& test02()
{
	static int a = 10; //静态变量存放在全局区 
	                   //该区数据由在整个程序结束后由系统释放
	return a;
}

int main()
{
	//引用做函数的返回值
	int& ref = test02();  //   int& ref = a;
	cout << "ref=" << ref << endl;
	cout << "ref=" << ref << endl;
	test02() =1000;   // 函数返回值为引用，函数test02 在赋值的左边
	cout << "ref=" << ref << endl;
	cout << "ref=" << ref << endl;
		system("pause");
    	return 0;
}

test02返回的是该函数中a的引用，即 把 a 的变量做了一个返回，
所以
test02() =1000; 即 a = 1000; 同时 ref 也是 a 的别名
如果函数的返回值是引用，这个函数可以作为左值

• 引用的本质 即是一个 指针常量（指针的指向不可修改，但指向的值 可修改）
  int a = 10; 若地址为 0x0011
  int& ref = a ;
  自动转换为 int* const ref = &a; 因为const 所以不可改指向的地址
  指针 ref 内保存的数据为 a的地址 0x0011 ，
  ref =20;// 内部发现 ref 是引用，自动帮我们转换成 *ref = 20 ;
  输出 ref 也会自动转换成 *ref

• 常量引用
  用来修饰形参，防止误操作。

注意： 引用必须引用一块合法的空间
不能
int & ref =10 ;
但是
const int & ref = 10 ;
可以 编译器会将代码修改为 int temp =10 ; const int & ref =temp; 且不能修改。

void test02(int &Val)
{
	 Val = 1000;
	cout << "Val =" << Val << endl;
}

int main()
{
	int a = 10;
	test02(a);
	system("pause");
   	return 0;
}

引用传递形参可修饰实参

若加上const Val则不能被修改