C++在程序运行时，将内存大方向分为四个区：

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

内存四区的意义：不同区域存放的数据，赋予不同的生命周期，增大编程灵活性。

一、代码区

生成时间：
生成exe文件后，在程序未执行前生成。
作用：
存放CPU执行的机器代码。
特点：
共享：内存中只存在一份数据，多次执行访问同一份指令空间；
只读：防止程序意外地修改指令。

二、全局区

生成时间：
生成exe文件后，在程序未执行前生成
作用：
全局变量和静态变量存放在此；
还包含常量区、字符串区和其他常量（const）；
该区数据在程序结束后由操作系统进行释放。

运行以下代码可观察内存中不同变量存放地址的关系：

  1. #include<iostream>
  2. using namespace std;
  4. //C++在程序运行时，将内存大方向分为四个区：
  5. //1、代码区：存放函数体的二进制代码，由操作系统进行管理
  6. //2、全局区：存放全局变量、静态变量和常量
  7. //3、栈区：编译器自动分配和释放，存放函数的参数值、局部变量等
  8. //4、堆区：由程序员分配和释放，若程序员不释放，程序结束时由操作系统回收
  10. //内存四区的意义：不同区域存放的数据，赋予不同的生命周期，增大编程灵活性
  12. //
  13. //代码区：生成exe文件后，在程序未执行前生成
  14. //作用：
  15. //存放CPU执行的机器代码
  16. //共享：内存中只存在一份数据，多次执行访问同一份指令空间
  17. //只读：防止程序意外地修改指令
  19. //
  20. //全局区：生成exe文件后，在程序未执行前生成
  21. //作用：
  22. //全局变量和静态变量存放在此
  23. //还包含常量区、字符串区和其他常量（const）
  24. //该区数据在程序结束后由操作系统进行释放
  26. //创建全局变量
  27. int g_a = 10;
  28. int g_b = 10;
  30. //创建全局常量
  31. const int c_g_a = 10;
  33. int main()
  34. {
  35.     //全局区
  37.     //全局变量、静态变量、常量
  39.     //创建普通局部变量
  40.     int a = 10;
  41.     int b = 10;
  43.     cout << "局部变量a的地址为：" << (int)&a << endl;    //观察不同变量的地址空间
  44.     cout << "局部变量a的地址为：" << (int)&b << endl;
  46.     cout << "全局变量g_a的地址为：" << (int)&g_a << endl;
  47.     cout << "全局变量g_b的地址为：" << (int)&g_b << endl;
  49.     //创建静态变量
  50.     static int s_a = 10;
  51.     static int s_b = 10;
  53.     cout << "静态变量s_b的地址为：" << (int)&s_b << endl;
  54.     cout << "静态变量s_a的地址为：" << (int)&s_a << endl;
  56.     //常量
  58.     //1、字符串常量
  59.     cout << "字符串常量的地址为：" << (int) &"hello world" << endl;
  61.     //2、const修饰常量（const修饰的全局常量、const修饰的局部变量）
  63.     const int c_l_a = 10;
  65.     cout << "全局常量c_g_a的地址为：" << (int)&c_g_a << endl;     //存放在全局区
  66.     cout << "局部常量c_l_a的地址为：" << (int)&c_l_a << endl;     //不在全局区，和局部变量在一起
  68.     system("pause");
  70.     return 0;
  71. }
  73. //总结：
  75. //全局区：全局变量、静态变量、const修饰全局常量、字符串常量

三、栈区

由编译器自动分配释放，存放函数的参数值、局部变量。
注意：
不要返回局部变量的地址，栈区开辟的数据由编译器自动释放。

  1. #include<iostream>
  2. using namespace std;
  4. //栈区
  5. //由编译器自动分配释放，存放函数的参数值、局部变量
  7. //注意事项：不要返回局部变量的地址，栈区开辟的数据由编译器自动释放
  9. int *func()
  10. {
  11.     int a = 10;   //局部变量,存放在栈区，在程序执行完毕后自动释放
  13.     return &a;
  14. }
  16. int main() 
  17. {
  18.     int* p = func();
  20.     cout << *p << endl;   //在32位系统系统会保留一次，输出10
  22.     cout << *p << endl;   //系统自动释放，输出不为10
  25.     system("pause");
  27.     return 0;
  28. }

四、堆区

由程序员分配释放，若程序员不释放，则会在程序结束后系统自动收回。

（一）new语句

利用new关键字，可以将数据开辟到堆区，new语句一般形式为：

new 类型 [m][n]
或
new 类型（初值）

开辟指定数据类型的空间，并返回地址。
new 类型 [m][n]：表示开辟一个数组（尺寸为mn）的空间，并返回数组首地址；
*new 类型（初值）：表示开辟一个指定数据类型的空间，赋初值，并返回地址。

  1.     //开辟一个整数空间，并赋初值为10，并返回地址
  2. *p = new int(10);
  3.     //开辟一个一维数组（1*10）的空间，并返回数组首地址
  4. new int[10];

（二）delete语句

delete语句用于撤销用new开辟的存放数据的空间。一般形式为：

delete 指针变量
或
delete [] 指针变量

delete 指针变量：用于撤销变量的空间；
delete [] 指针变量：用于对数组变量的空间的撤销。

  1.    //释放上述开辟的整形数的空间
  2. delete p;
  3.     //在指针变量前加上方括号，表示对数组空间的操作
  4. delete [] arr
  1. #include<iostream>
  2. using namespace std;
  4. //堆区
  5. //由程序员分配释放，若程序员不释放，则会在程序结束后系统自动收回
  7. //在C++中主要利用new在堆区开辟内存 语法 new 数据类型
  9. //可以利用操作符delete释放
  11. int* func()
  12. {
  14.     //利用new关键字，可以将数据开辟到堆区
  16.     //指针本质上也是变量，存放在栈区，指向的数据存放在堆区
  18.     int* p = new int(10);   //new返回的是该数据类型的指针
  20.     return p;
  21. }
  23. //利用new在堆区开辟数组
  25. void test()
  26. {
  27.     //在堆区开辟10个元素的整形数组
  29.     int* arr = new int[10];  //中括号，注意与上边区分
  31.     delete[] arr;  //释放数组需要加上中括号
  32. }
  34. int main()
  35. {
  37.     //在堆区开辟内存
  38.     int* p = func();
  40.     cout << *p << endl;      //数据一直存在
  42.     cout << *p << endl;  
  44.     delete p;
  48.     //cout << *p << endl;    //内存已被释放，再进行访问就会出错
  51.     system("pause");
  53.     return 0;
  54. }

END