11、C++引用

一、 引用基本使用

int a=10;

int &b=a;     //b是a的引用（别名)

不管是通过a修改，还是b修改那块内存的值，

修改后，a,b的值一样都是那块内存中被修改 了的值

二、引用的注意事项

引用必须初始化

初始化后，不可以更改 （b已经是a的引用，那么b就不可以再为其他变量的引用）

int a = 10 ,  c=20;

int &b = a;

b=c;  //这不是更改引用，而

是赋值，（把c的值赋值给b和a）

三、引用做函数参数

优点: 简化指针修改参数、方便直观（和指针）作用相同

四、引用做函数返回值

int& test01()
{
    int a = 10;       //a在栈区开辟内存
    return a;         //返回在栈区开辟的内存，以引用的方式
}

int& test02()
{
    static int a = 20;   //静态变量，存放在全局区，操作系统回收，

                                 //生命周期长，程序运行的整个时间存在
    return a;
}

int &ret = test01();            //ret=10

int &ret2 = test02();           //ret=乱码

1、不要返回局部变量的引用

//test01() 函数调用之后，保存在栈区的test01局部变量a销毁

//test02()函数调用之后，保存在全局区的test02局部变量a任然存在

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

test02() = 30;     //test02()函数相当于一个变量 

#include<iostream>
using namespace std;

int& test01()
{
	int a = 10;       //a在栈区开辟内存
	return a;         //返回在栈区开辟的内存，以引用的方式
}

int& test02()
{
	static int a = 20;   //静态变量，存放在全局区，操作系统回收，声明周期长，程序运行的整个时间存在
	return a;
}


int main()
{
	//1、不要返回局部变量的引用
	

	int& ret = test01();       //以引用的方式，接收函数返回值，则函数返回值类型要为引用

	//1、不要返回局部变量的引用		  //函数调用之后，保存在栈区的test01局部变量销毁
	cout << "ret=" << ret << endl;          //正确，第一次，编译器做了保留，可以知道栈区的局部变量a
	cout << "ret=" << ret << endl << endl; //乱码，第一次后，不做保留，不知道a了


	int& ret2 = test02();
	cout << "ret=" << ret2 << endl;			   //正确,20
	cout << "ret=" << ret2 << endl << endl;    //正确,20
    

    //2、函数的调用可以作为左值
	test02() = 30;     //test02()函数相当于一个变量
	cout << "ret=" << ret2 << endl;			   //正确,30
	cout << "ret=" << ret2 << endl << endl;    //正确,30


	system("pause");
	return 0;
}

五、引用的本质：指针常量

指针常量：int* const pa = &a;

常量指针：const int* pb = &b ;   b=10;

// 引用的本质：指针常量

int a = 10;

int& ref = a;    //int* const ref = &a;    //ref为指针常量

ref = 20;    //内部发现ref是引用，自动转换成  *ref=20;

所以，引用一旦定义初始化，就不能不能作为其他变量的引用（指向不能发生改变）

所有的指针操作，编译器都帮我们完成（发现为引用，转化为指针） 

#include<iostream>
using namespace std;

//发现是引用，转换为：int* const ref = &a;
void func(int& ref)
{
	ref = 100;  //内部发现ref为引用，自动转换为 *ref=100;
}

int main()
{
	int a = 10;

	//引用的本质：指针常量
	int& ref = a;    //int* const ref = &a;    //ref为指针常量
	ref = 20;    //内部发现ref是引用，自动转换成  *ref=20;

	cout << "a=" << a << endl;
	cout << "ref=" << ref << endl;

	func(a);	//int* const ref = &a;

	system("pause");
	return 0;
}

六、常量引用：（修饰形参，防止函数改变了传过来的实参）

1、引用本身需要一个合法的空间

int& ref = 10;       ×    

2、加上const,编译器优化代码，创建临时变量temp=10，然后，const int& ref=temp;

const int& ret = 20;     √

 3、引用常量：使用引用在节省内存的情况下，加const还可以防止修改

 //引用目的：防止产生副本，浪费内存。（加上const：是防止修改实参）

void printA(const int& a)      
{
    //a = 999;  ×
    cout << "printA()  a=" << a << endl;
}