C++内存分布模型 代码区，全局区，堆区，栈区

c++内存分区模型

1.代码区：存放函数体的二进制代码，由操作系统进行管理的
2.全局区：存放全局变量和静态变量以及常量
3.堆区：由编译器自动分配释放, 存放函数的参数值,局部变量等
4.栈区：由程序员分配和释放,若程序员不释放,程序结束时由操作系统回收

那么内存的分区对咱们有什么意义呢？
其实就是为了让我们的编程能够更加灵活，不同的变量放在不同的内存里，避免冲突。

1.程序运行前
以.exe为后缀的文件（其实就是程序），在你双击之前（即程序没运行的时候）
咱们可以把内存分为两个区块代码区和全局区

1.1代码区
代码区就是编译好的二进制文件，不可以修改，并且同一个文件不会重复生成

代码区具有共享性：即对于频繁执行的程序，只会生成一份代码，不会生成多分代码。
代码具有只读性：即你不可以对代码区的指令进行修改。

1.2全局区
全局变量，静态变量，字符串常量，其他常量都存放在全局
该区域内的数据在程序结束后由奥做系统管理和释放，而不由我们管理

//1.全局变量
int g_a = 10;//g_a 是全局变量a的意思，英汉互译的命名方式
int g_b = 10;//同上
//2.全局常量const修饰的全局变量
const int c_g_a = 10;
const int c_g_b = 10;
int main ()
{
	//3.局部变量
	int a = 10;
	int b = 20;
	//4.静态变量
	static int s_a = 10;
	static int s_b = 10;
	//5.字符串常量 "Hello Word"
	//6.局部常量 const 修饰的局部变量
	const int c_l_a = 10;//l 是local 代表局部的意思
	const int c_l_b = 10;

	cout << "局部变量 a的地址 = " <<int( &a)<< endl;
	cout << "局部变量 b的地址 = " << int(&b)<< endl;

	cout << "全局变量 g_a的地址 = " << int(&g_a)<< endl;
	cout << "全局变量 g_b的地址 = " << int(&g_b)<< endl;

	cout << "全局常量 c_g_a的地址 = " << int(&c_g_a)<< endl;
	cout << "全局常量 c_g_b的地址 = " << int(&c_g_b)<< endl;

	cout << "静态变量 s_a的地址 = " << int(&s_a)<< endl;
	cout << "静态变量 s_b的地址 = " << int(&s_b)<< endl;

	cout << "字符串常量的地址 = " << int(&"Hello Word")<< endl;

	cout << "局部常量 c_l_a的地址 = " << int(&c_l_a)<< endl;
	cout << "局部常量 c_l_b的地址 = " << int(&c_l_b)<< endl;
/*
	局部变量 a的地址 = 18282376
	局部变量 b的地址 = 18282364

	全局变量 g_a的地址 = 2359564
	全局变量 g_b的地址 = 2359568

	全局常量 c_g_a的地址 = 2350016
	全局常量 c_g_b的地址 = 2350020

	静态变量 s_a的地址 = 2359572
	静态变量 s_b的地址 = 2359576

	字符串常量的地址 = 2350336

	局部常量 c_l_a的地址 = 18282352
	局部常量 c_l_b的地址 = 18282340
*/


	system("pause");
	return 0;
}

由代码知

在全局区中的变量	不在全局区中的变量
全局变量（函数外命名）	局部变量（函数内定义的普通变量）
静态变量（由static关键字修饰）	const修饰的局部变量（即局部常量）
字符串常量
const修饰的全局变量

2.程序运行后
2.1栈区
由编译器自动分配和释放，用于存放函数的参数，局部变量

不要返回局部变量的地址

//栈区数据的注意事项
//由编译器开辟和释放

 int * func()
{
	int a = 10;//局部变量 存放在栈区，栈区的数据执行后完成自动释放
	return &a;//返回局部变量的地址
}

int main() {

	int *p = func();//接受返回的局部变量的地址

	cout <<"p指针所指向的值 = "<< *p << endl;
	cout <<"p指针所指向的值 = "<< *p << endl;
	cout <<"p指针所指向的值 = "<< *p << endl;
	cout <<"p指针所指向的值 = "<< *p << endl;
	cout <<"p指针所指向的值 = "<< *p << endl;
	cout <<"p指针所指向的值 = "<< *p << endl;
	/*
	p指针所指向的值 = 10//第一次由于编译器的保存而没有乱码，后面都乱码
	p指针所指向的值 = 2064958432
	p指针所指向的值 = 2064958432
	p指针所指向的值 = 2064958432
	p指针所指向的值 = 2064958432
	p指针所指向的值 = 2064958432
	*/
	system("pause");
	return 0;
}

在func函数中，函数运行后a变量被释放了，所以指针p接受的地址是一个随意指向的地址。
不要返回局部变量的地址

2.2堆区
由程序员分配释放，如果程序员不释放，程序结束时由操作系统回收
在c++中主要利用new在堆区开辟内存
（new操作符在下面会提）

int * fun()
{
	//利用new关键字可以将数据开辟到堆区
	//new 返回的是该数据类型的指针
	int * p = new int (10);
	return p;
	/*
	其实这里很简单，大家都知道栈区里函数运行结束后,
	变量就会被释放（指针p就会被释放），但是我在堆区开放一个新的区域
	（程序员自动控制的区域）用以存放变量的值，
	注意哦，不是存放变量，只是把它的值存放起来
	当然，栈区里面的变量指针p指向的就是堆区里面的值
	*/

}


int main ()
{
	//在堆区开辟数据

	int *p = fun();
	cout <<"p指针所指向的值 = "<< *p << endl;
	cout <<"p指针所指向的值 = "<< *p << endl;
	cout <<"p指针所指向的值 = "<< *p << endl;
	cout <<"p指针所指向的值 = "<< *p << endl;
	/*
	p指针所指向的值 = 10
	p指针所指向的值 = 10
	p指针所指向的值 = 10
	p指针所指向的值 = 10
	*/
	delete p;//将堆区中p指向的值释放
	cout <<"p指针所指向的值 = "<< *p << endl;
	cout <<"p指针所指向的值 = "<< *p << endl;
	/*
	p指针所指向的值 = -17891602//出现乱码，是由于清除p指向的堆区的存放的值，p乱值。
	p指针所指向的值 = -17891602
	*/
	system("pause");
	return 0;
}

总结 ：栈区的数据咱们不能控制，函数一结束他就释放了。所以咱们用一个new操作符，将他的值存放在程序员能控制的堆区，然后用栈区的变量指针指向这个存放的值。

举例在堆区创建数组

void test ()
{
	//在堆区创建10整型数据的数组
	int * arr = new int [10];
	for (int i = 0;i < 10; i ++ )
	{
		arr[i] = i+100;
	}
	for(int i = 0; i < 10;i++)
	{
		cout <<"arr["<<i<<"]"<<" = "<< arr[i] <<endl;
	}
	delete [] arr ;//释放数组的时候要加[]中括号
	//将数组arr释放后
	cout <<"释放数组arr[]后"<<endl;
	for(int i = 0; i < 10;i++)
	{
		cout <<"arr["<<i<<"]"<<" = "<< arr[i] <<endl;
	}
}

int main ()

{
	test();
	system("pause");
	return 0;
}
/*
arr[0] = 100
arr[1] = 101
arr[2] = 102
arr[3] = 103
arr[4] = 104
arr[5] = 105
arr[6] = 106
arr[7] = 107
arr[8] = 108
arr[9] = 109	正常输出
"释放数组arr[]后"
arr[0] = -17891602
arr[1] = -17891602
arr[2] = -17891602
arr[3] = -17891602
arr[4] = -17891602
arr[5] = -17891602
arr[6] = -17891602
arr[7] = -17891602
arr[8] = -17891602
arr[9] = -17891602	乱码输出
*/