【C++】内存分区&引用

内存分区：

首先我们要了解，内存区域大概分为四个区域：
1.代码区：这里主要存放我们写的代码的二进表达式，即CPU可以看懂的机械指令。这个区域有两个特征：只读和共享；前者可以保证代码的不会被随意修改；后者可以保证相同代码多次阅读不需要创建多个副本。
2.全局区：这里主要存放的是静态的变量、全局变量、常量等；这里的常量可以细分为字符串常量和全局常量，而局部常量（const修饰的在main函数内部的常变量）。

int a = 10;//全局变量
const int b = 10;//全局常量


int main()
{
	static int c = 10;//静态变量
	const int d = 10;//局部常量
	"abcedf";//字符串常量

---

上面的两个区都是在程序运行前就已经存在，而程序运行后才会涉及下面的两个区
3.栈区：栈区上面主要由编译器分配，开辟空间来存放函数的局部变量、形参等，在函数结束后会自动释放，生命周期由编译器决定。
4.堆区：堆区是由操作者自己开辟的空间，在程序结束后由操作系统统一回收。
这里关于在堆区开辟空间的概念，与我们在C语言中类似，在C语言中我们使用malloc函数来开辟堆区内存，而在C++中我们使用new关键字来开辟内存：

new关键字用法：

整型创建

首先我们来看一种简单的开辟：
我们要开辟一个int类型变量的空间，用new语句实现的结构如下：

写成代码形式就是：

int* p = new int(10);

类似于C语言中的：

int* p = (int)malloc(sizeof(int));
*p = 10;

类似的，用完也要对内存空间进行释放，这里C++用的是delete关键字：

delete p;
p = NULL;

一维数组创建

一维数组创建与整型差不多，结构上有细微的差别：

int* arr = new int[10];

它的int后面跟的不再是赋予初始值的”()“，而是"[]"。表示开辟的是数组的连续空间。中括号里面跟的就是数组的大小。
类似的，我们释放内存就要提示编译器，释放的是数组的内存空间；

delete [] arr;
arr = NULL;

二维数组创建

二维数组的创建就有点麻烦了，假设我们需要开辟一个5行3列的二维数组。
我们需要先创建一个二级指针来指向这个数组，然后开辟存放每一行的一维数组的首地址所需的内存空间；然后写一个循环结构：开辟每一行数组的空间；具体实现如下：

//用new创建二维数组
	const int M = 5, N = 3;
	int** qarr =NULL ;
	qarr = new int* [M];//开辟每一行一维数组的首地址的空间
	int flag = 0;
	for (int i = 0; i < M; i++)
	{
		qarr[i] = new int[N];//每一个一维数组里每一个元素都要开辟自己的空间
		for (int j = 0; j < N; j++)
		{
			qarr[i][j] = flag;
			flag++;
		}
	}
	for (int i = 0; i < M; i++)
	{
		for (int j = 0; j < N; j++)
			printf("%d ", qarr[i][j]);
		printf("\n");
	}
	for (int i = 0; i < M; i++)
		delete[]qarr[i];
	delete[]qarr;

对应的，因为我们是先开辟二维数组中每一行的一维数组的首地址空间，再开辟每一行中每一个元素的空间，所以我们释放的时候，应该先释放每一个数组中的每一个元素的空间，再释放存放一维数组首地址的内存空间

引用

引用可以理解为给变量起一个别名，例如你的名字和你的身份证号都是指的你；它与我们C语言中的typedef不同，它是为变量起别名；
它的一般结构是：

int a = 89;
int& b = a;

这里我们输出a和b，就会发现它们是一致的，都是再同一块内存上变化。

int main()
{
	int a = 89;
	int& b = a;
	cout << a << endl;
	cout << b << endl;
	a = 10;
	cout << a << endl;
	cout << b << endl;
	b = 78;
	cout << a << endl;
	cout << b << endl;
	return 0;
}

输出如下：

引用的注意事项：

1.引用不能在初始化前；我们可以理解为，你是先有名字，然后再去拿你的身份证，不可能先有你的身份证而没有你的名字；

2.一旦引用，引用对象就不能更改；这个可以简单理解为，你的身份证号就是你自己，不可能你的身份证号指的是别人；

3.引用不能作为函数返回值：因为引用本质就是函数使用时在栈区开辟的空间，一旦函数结束，那么开辟的变量空间也会被释放，所以即使你返回了这块空间的引用，但是本质上还是指向这块空间，一旦这块空间被释放，那么后续即使能访问指向的这块空间，但这是非法访问了！

int& func()
{
	int a = 10;
	int& b = a;
	return b;
}
int main()
{
	int &c = func();
	cout << c << endl;
	return 0;
}

4.引用可以作为左值： 这里 我们需要理解，引用是可以作为左值的，也就是说可以作为等号的左边，即它是可以被改变的。

int main()
{
	int a = 10;
	int &c = a;
	c = 100;
	cout << c << endl;
	return 0;
}

5.引用可以作为形参修饰实参：；我们知道，函数的局部变量会在函数结束生命周期结束，那么如果我们接收的形参是实参的引用呢？那么函数的形参和实参就可以理解为都是指向同一块内存的变量名，当改变形参(实参的引用)，那么实参也会发生变化。

其实引用的实质就是一个指针常量！

若int &b=a；
那么以后看到b就等价于*a， 所以int &b=a就类似于 int *const b=&a；

6.常量引用： 有时侯，如果我们的函数参数选择引用来接收实参，那么我们可能会不经意修改了实参的内容，所以我们可以设计一种常量引用，这种方法可以保证引用不会被修改（感觉类似于const int* x，不能通过解引用来改变x的值）；

void print(const int &c)
{
	//c=102;--非法操作，加了const的引用不能改
	cout << c << endl;
}

int main()
{
	int a = 10;
	int& b = a;
	const int& d = a;
	print(a);
	b = 100;//引用可以改
	cout << b << endl;
	a = 101;//变量可以改
	cout << a << endl;
	//d = 103;--非法操作，加了const的引用不能改
	return 0;
}