C++学习--引用

---

一、内存分区模型

C++程序在执行时，将内存大方向划分为4各区域：
1、代码区：存放函数体的二进制代码，由操作系统进行管理
2、全局区：存放全局变量、静态变量以及部分变量等
3、栈区：由编译器自动分配释放，存放函数的参数值、局部变量等。
4、堆区：由程序员分配和释放，若程序员不释放，程序结束时由操作系统回收

意义：
不同的区域存放的数据，赋予不同的生命周期

1.1程序运行前

在程序编译后，生成了exe可执行程序，未执行该程序前分为两个区域：代码区以及全局区

代码区：

存放CPU执行的机器指令 代码区是共享的，共享的目的时对于频繁被执行的程序，只需要在内存中有一份代码即可
代码区是只读的，使其只读的原因是防止程序意外地修改了它的指令

全局区：

全局变量和静态变量存放在此 全局区还包含了常量区，字符串常量和其他常量（const修饰的全局变量）也存放在此
该区域的数据在程序结束后由操作系统释放

变量分类

局部变量（不在全局区）：在main函数中定义的变量 全局变量：在main函数外定义的变量 静态变量：在普通变量前加static，static
int a=10 常量： 字符串常量：用“”修饰的，&“hello’”
const修饰的变量：分为const修饰的全局变量和const修饰的局部变量（不在全局区），

1.2程序运行后

栈区：

由编译器自动分配释放，存放函数的参数值（形参数据），局部变量等
注意：不要返回局部变量（return）的地址，因为局部变量在函数执行完由编译器自动释放

堆区：

程序员分配释放，若程序员不释放，程序结束后由操作系统回收
在C++中主要利用new在堆区开辟内存。

利用new关键字，可以将数据开辟到堆区（new返回的是该数据类型的指针）
利用delete释放内存

int * func()
{
//指针本质上也是局部变量，仍然放在栈区，指针保存的数据是在堆区的数据
	int * p = new int(10);
	return p;
}

void test1()
{
	int *p=func();
	cout<<*p<<endl;
	//堆区的数据由管理员管理开辟，管理员管理释放
	//如果想释放堆区的数据，利用关键字delete（释放数组时，需要加【】）
	delete p;
	cout<<*p<<endl;//内存已经被释放，再次访问就是非法
}

//在堆区开辟数组
void test2()
{
	//创建10个整形数据的数组，在堆区
	int *arr = new int[10];//这里的10代表数组有10个元素
	for(i=0;i<10li++)
	{
		arr[i]=i+100;
	}
	//释放队去数组
	//释放数组的时候，需要加【】
	delete[] arr;
}

二、引用

引用：给变量起别名
语法：数据类型 &别名=原名

int a=10;
int &b=a;	//创建引用
b=20;
cout<<a<<endl;//a=20，因为a，b代表的一样，指向同一块内存

注意：引用必须要初始化，引用初始化之后就不能更改了

引用必须初始化
int a=10;
int &b; //×，没有初始化
int &b=a；//√

引用初始化后，不能改变
int c=20；
b=c；   //这是赋值操作，而不是更改引用

1.引用做函数参数

作用：函数传参时，可以利用引用的技术让形参修饰实参
优点：可以简化指针修饰实参

//1、值传递，对实参没有影响
void swap1（int a,int b）
{
	int temp=a;
	a=b;
	b=temp;
}
//2、地址传递
void swap2（int *a,int *b）
{
	int temp=*a;
	*a=*b;
	*b=temp;
}
//3、引用传递
void swap3（int &a,int &b）
{
	int temp=a;
	a=b;
	b=temp;
}

int main(){
	int a=10;
	int b=20;
	swap1(a,b);  	   //实参a，b不会改变
	swap2(&a,&b); 	  //实参a，b会改变
	swap3(a,b);  	 //实参a，b会改变
}

2.引用做函数返回值

注意：不要返回局部变量引用
用法：函数调用作为左值

int& test1()
{
	int a=10;//局部变量存放在栈区
	return a;
}

int& test2()
{
	static int a=10;//静态变量，存放在全局区，全局区上的数据在程序结束后系统释放
	return a;
}
int main(){
//1、	
	int &ref=test1();  // × a有一个别名返回给了ref 此时打印ref以及没有内容了，被释放了
	int &ref=test2(); //是正确的，因为整个程序结束了才释放
	cout<<"ref=  "<<ref<<endl; //等于10

//2、
	test2()=1000; //因为本身返回的就是a的引用，所以实际做了a=1000操作，因为函数的返回值是引用，所以可以作为左值存在
	cout<<"ref=  "<<ref<<endl; //ref相当于a的别名，所以也等于1000
	
}

3、引用的本质

引用的本质在C++内部的实现是一个指针常量。
（指针常量：指针的指向不可以修改，指针常量的值可以修改）
（解释了一旦引用初始化，就不可以改变）

//发现是引用，转换为int* const ref=&a
void func(int& ref)
{
	ref=100; //ref是引用，转换为*ref=100
}
int main(){
	int a=10;
	//自动转换为 int* const ref=&a，指针常量的指针指向不可改，所以引用不可改
	int& ref=a;
	ref=20;   //内部发现ref是引用，自动转换为*ref=20
//此时a=20，ref=20

	func(a);
	return 0;
	
}

4、常量引用

用来修饰形参，防止误操作。
在函数形参列表中，可以加const修饰形参，方式形参改变实参

void showvalue(const int &val)  
{
	val=1000;
	cout<<"val="<<val<<endl;
} 
//此时val=1000会报错，如果没有const，val=1000将外侧实参也进行了修改
int main(){
	int a=10;
	int &ref=10;//×，引用必须引一块合法的内存空间
	
	const int &ref=10;//√，因为加conts之后，编译器将代码修改为 int temp=10；const int &ref=temp
	ref=2； //×，因为加const之后变成只读，不可以修改

	showvalue(a);
	cout<<"a= "<<a<<endl;
	return 0; 
}