（2）内存四区、new操作符，引用做函数参数、返回值、引用本质、常量引用

C++程序在执行时，将内存大方向划分为4个区域：

代码区：存放函数体的二进制代码，由操作系统进行管理

全局区：存放全局变量和静态变量以及常量

栈区：由编译器自动分配释放，存放函数的参数值，局部变量等

堆区：由程序员分配和释放，若程序员不释放，程序结束时由操作系统回收

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

程序编译后，生成exe可执行程序，未执行该程序前分为代码区和全局区：

代码区：

存放CPU执行的机器指令

代码区是共享的，内存中有一份代码，可频繁被执行

代码区是只读的，防止程序意外地修改了它的指令

全局区：

存放全局变量、静态变量、常量

常量区中存放字符串常量、全局常量（const修饰的全局变量）

全局区的数据在程序结束之后由操作系统释放

不存放局部变量、局部常量（const修饰的局部变量）

#include<iostream>
using namespace std;

int g_a = 10;//全局变量，函数体之外的变量
int g_b = 10;

const int c_g_a = 10;//全局常量，const修饰的全局变量
const int c_g_b = 20;
int main() {
	int a = 10;//局部变量，函数体内的变量
	int b = 20;
	cout << "局部变量a的地址：" << (int)&a << endl;
	cout << "局部变量b的地址：" << (int)&b << endl;
	cout << "全局变量g_a的地址：" << (int)&g_a << endl;
	cout << "全局变量g_b的地址：" << (int)&g_b << endl;

	static int s_a = 10;//静态变量,普通变量前加static
	static int s_b = 10;
	cout << "静态变量s_a的地址：" << (int)&s_a << endl;
	cout << "静态变量s_b的地址：" << (int)&s_b << endl;
	cout << "字符串常量的地址：" << (int)&"hello" << endl;
	cout << "全局常量c_g_a的地址：" << (int)&c_g_a << endl;
	cout << "全局常量c_g_b的地址：" << (int)&c_g_b << endl;
	const int c_l_a = 10;//局部常量 c--const  g--global(全局）  l--local(局部)
	const int c_l_b = 10;
	cout << "局部常量c_l_a的地址：" << (int)&c_l_a << endl;
	cout << "局部常量c_l_b的地址：" << (int)&c_l_b << endl;
}

栈区

不要返回局部变量的地址，栈区开辟的数据由编译器自动释放

int * func(int b)//形参b也会放在栈区
{
	b = 100;
	int a = 10;//局部变量，存放在栈区，栈区数据在函数执行完后自动释放
	return &a;//返回局部变量地址
}
int main() {
	int * p = func(1);//接收func函数返回值
	cout << *p << endl;//第一次可打印正确，因为编译器做了保留
	cout << *p << endl;//第二次数据就不再保留，因此不会打印成功
	return 0;
}

堆区

在C++中主要利用new关键字在堆区开辟内存

堆区数据由程序员管理开辟和释放

int * func()
{
	//指针 本质是局部变量，放在栈区，指针保存的数据放在堆区
	int * p = new int(10);//利用new关键字，将数据开辟到堆区
	return p;
}
int main() {
	int *p = func();
	cout << *p << endl;//打印10
	cout << *p << endl;//打印10
	return 0;
}

new操作符

程序员利用new在堆区手动开辟数据，手动释放，释放利用操作符delete

语法：new 数据类型

利用new创建的数据，会返回该数据对应的类型的指针

int* func(){
	int* p = new int(10);//在堆区创建整型数据，new 返回是 该数据类型的指针
	return p;
}
void test01() {
	int* p = func();
	cout << *p << endl;
	cout << *p << endl;
	delete p;//释放数据
	//cout << *p << endl;//内存已释放，不能访问，会引发异常
}
void test02() {//利用new在堆区开辟数组
	int * arr = new int[10];//创建10个整型数据的数组
	for (int i = 0; i < 10; i++) {
		arr[i] = i + 100;
	}
	for (int i = 0; i < 10; i++) {
		cout << arr[i] << endl;
	}
	delete[] arr;//释放数组时要加[]
}
int main() {
	test01();
	test02();
}

引用

作用：给变量起别名

语法：数据类型 &别名 = 原名

别名和原名访问同一块内存，并且可以对内存数据进行更改

int main() {
	int a = 20;
	int &b = a;//引用初始化
	cout << "a = " << a << endl;//输出20
	cout << "b = " << b << endl;//输出20
	b = 10;
	cout << "a = " << a << endl;//输出10
	cout << "b = " << b << endl;//输出10
	return 0;
}

注：

引用必须初始化

引用初始化后，不可以改变（如，b初始化成a的别名后就只能是a的别名，不能再成为c的别名）

引用做函数参数

作用：函数传参时，可利用引用的技术让形参修饰实参

优点：可以简化指针修改实参

通过引用参数产生的效果同按地址传递是一样的，引用的语法更清楚简单

void mySwap01(int a, int b) {//值传递
	int temp = a;
	a = b;
	b = temp;
	cout << "mySwap01 a = " << a << endl;//a = 300
	cout << "mySwap01 b = " << b << endl;//b = 10
}
void mySwap02(int *a,int *b) {//地址传递
	int temp = *a;
	*a = *b;
	*b = temp;
}
void mySwap03(int &a, int &b) {//引用传递
	int temp = a;
	a = b;
	b = temp;
}
int main() {
	int a = 10;
	int b = 300;
	//注释掉值传递和地址传递是为了不影响引用传递
	//mySwap01(a, b);//值传递，形参不会修饰实参
	//cout << "a1 = " << a << endl;//a1 = 10
	//cout << "b1 = " << b << endl;//b1 = 300
	//mySwap02(&a, &b);//地址传递，形参会修饰实参
	//cout << "a2 = " << a << endl;//a2 = 300
	//cout << "b2 = " << b << endl;//b2 = 10
	
	//mySwap03中的 &a 和 &b 相当于这里 a 和 b 的别名
	mySwap03(a, b);//引用传递，形参会修饰实参
	cout << "a3 = " << a << endl;//a3 = 300
	cout << "b3 = " << b << endl;//b3 = 10
}

引用做函数的返回值

注：不要返回局部变量引用

函数调用做左值

int& test01() {//不要返回局部变量的引用，会引发异常
	int a = 10;//局部变量存放在 栈区,test01执行完被释放
	return a;
}
int& test02() {//如果函数返回值是引用，函数的调用可以作为左值
	static int a = 10;//静态变量存放在 全局区，程序结束后系统释放
	return a;//返回a的引用
}
int main() {
	int &ref = test01();
	cout << "ref = " << ref << endl;//打印成功，10，因为编译器的保留
	cout << "ref = " << ref << endl;//a内存已释放，打印失败
	int &ref2 = test02();
	cout << "ref2 = " << ref2 << endl;//打印成功，10
	cout << "ref2 = " << ref2 << endl;//打印成功,10
	test02() = 100;// = 左侧是左值，这里相当于做了一个a=100的操作，ref2是a别名
	cout << "ref2 = " << ref2 << endl;//打印成功,100
	cout << "ref2 = " << ref2 << endl;//打印成功,100
	return 0;
}

引用本质

在C++内部实现是一个指针常量

void func(int& ref) {
	ref = 100;
}
int main() {
	int a = 10;
	//指针常量是指针指向不可改，也说明为什么引用不可更改
	int& ref = a;//自动转换为int* const ref = &a;
	ref = 20;//内部ref是引用，自动转换为 *ref = 20;
	cout << "a = " << a << endl;// a = 20
	cout << "ref = " << ref << endl;// ref = 20
	func(a);
	return 0;
}

C++推荐使用引用技术，因为语法方便，引用本质是指针常量，但是所有的指针操作编译器帮我们做了

常量引用

作用：常量引用主要是用来修饰形参，防止误操作

在函数形参列表中，可以加const修饰形参，防止形参改变实参

void showValue(const int& val) {
	//val = 1000;形参加入const之后，不可修改
	cout << "val = " << val << endl;
}
int main() {
	//int& ref = 10;引用本身需要一个合法内存空间，因此此行错误,引用必须引一块合法内存空间
	//加上const之后，编译器将代码改为 int temp = 10;const int & ref = temp;
	const int &ref = 10;
	//ref = 100;//加入const后变为只读，不可以修改变量
	cout << ref << endl;
	//利用常量引用防止误操作修改实参
	int a = 10;
	showValue(a);
	cout << "a = " << a << endl;
	return 0;
}