内存分区模型
C++程序在执行时，将内存大致划分为 4个区域
- 代码区：存放函数体的二进制代码，由操作系统进行管理
- 全局区：存放 全局变量和 静态变量以及 常量
- 栈区：由 编译器自动分配释放，存放函数的 参数值、 局部变量等
- 堆区：由 程序员分配和释放，若程序员不释放，程序结束时由操作系统回收
代码区：所有的代码的英文字母、注释
内存四区意义：
不同区域存放的数据，赋予不同的生命周期，给我们更大的灵活编程
栈区数据由编译器管理，堆区由程序员管理
程序运行前，内存划分了两个区域是 代码区、 全局区
程序运行后，内存中才会有 栈区和 堆区
程序运行前
在程序编译后，生成了后缀名为exe的可执行程序， 未执行可执行程序前分为两个区域
代码区：
- 存放CPU执行的机器指令（就是所写的代码）
- 代码区是 共享的，共享的目的是对于频繁被执行的程序，只需要在内存中有一份代码即可，不造成资源浪费
所写的程序只要生成成功，就只有一份代码，不会因为每次要执行可执行程序，就再生成一份代码
- 代码区是 只读的，使其只读的原因是防止程序意外地修改了它的指令
全局区：
- 全局变量和 静态变量存放在此
- 全局区还包含了 常量区， 字符串常量和 全局常量（const修饰的全局变量）也存放在此
- 该区域的数据在程序结束后由操作系统释放
全局区
全局变量：没有写在函数体中的变量
全局变量与普通局部变量的地址比较：
// 全局变量
int g_a = 10;
int g_b = 10;
int main() {
// 局部变量
int a = 10;
int 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;
/*
局部变量 a 的地址为：11533284
局部变量 b 的地址为：11533272
全局变量 g_a 的地址为：1556532
全局变量 g_b 的地址为：1556536
局部变量和全局变量不在一个段里
*/
return 0;
}
从输出内容可以看出，局部变量和全局变量没有放在一个段里
静态变量与全局变量、局部变量的地址比较：
// 全局变量
int g_a = 10;
int g_b = 10;
int main() {
// 局部变量
int a = 10;
int b = 10;
// 静态变量
static int s_a = 10;
static int s_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 << "静态变量 s_a 的地址：" << (int)&s_a << endl;
cout << "静态变量 s_b 的地址：" << (int)&s_b << endl;
/*
局部变量 a 的地址为：10287852
局部变量 b 的地址为：10287840
全局变量 g_a 的地址为：3784756
全局变量 g_b 的地址为：3784760
静态变量 s_a 的地址为：3784764
静态变量 s_b 的地址为：3784768
全局变量和静态变量放在一块的，放在同一个区域段中
*/
return 0;
}
从输出可以看出来， 全局变量和 静态变量是放在一块的，属于同一个区段里，即都放在全局区中。
常量分为字符串常量、const修饰的两种变量（const修饰的全局变量：全局常量、const修饰的局部变量：局部常量）
但是保存在全局区的只有 字符串常量、 全局常量（const修饰的全局变量）
字符串常量与局部变量、全局变量、静态变量的地址比较：
// 全局变量
int g_a = 10;
int g_b = 10;
int main() {
// 局部变量
int a = 10;
int b = 10;
// 静态变量
static int s_a = 10;
static int s_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 << "静态变量 s_a 的地址：" << (int)&s_a << endl;
cout << "静态变量 s_b 的地址：" << (int)&s_b << endl;
cout << "字符串常量的地址：" << (int)&("hello world") << endl;
/*
局部变量 a 的地址为：8124700
局部变量 b 的地址为：8124688
全局变量 g_a 的地址为：9158708
全局变量 g_b 的地址为：9158712
静态变量 s_a 的地址为：9158716
静态变量 s_b 的地址为：9158720
字符串常量的地址为：9149284
常量区和全局变量、静态变量离得很近，全局变量和静态变量离得最近，常量区离他俩稍微有点距离
*/
return 0;
}
可以看出来，常量区的字符串常量和全局变量、静态变量都离得很近，同属于全局区，但是要细看的话，常量区和全局变量、静态变量稍微有点距离
const修饰的变量有两种
- const修饰的全局变量，称为 全局常量
- const修饰的局部变量，称为 *局部常量
放在全局区的是 全局常量
全局常量与局部变量、全局变量、静态变量、字符串常量的地址比较：
// 全局变量
int g_a = 10;
int g_b = 10;
// 全局常量：const修饰的全局变量
const int c_g_a = 10;
const int c_g_b = 10;
int main() {
// 局部变量
int a = 10;
int b = 10;
// 静态变量
static int s_a = 10;
static int s_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 << "静态变量 s_a 的地址：" << (int)&s_a << endl;
cout << "静态变量 s_b 的地址：" << (int)&s_b << endl;
cout << "字符串常量的地址：" << (int)&("hello world") << endl;
cout << "全局常量 c_g_a 的地址：" << (int)&c_g_a << endl;
cout << "全局常量 c_g_b 的地址：" << (int)&c_g_b << endl;
/*
局部变量 a 的地址为：6224956
局部变量 b 的地址为：6224944
全局变量 g_a 的地址为：4833332
全局变量 g_b 的地址为：4833336
静态变量 s_a 的地址为：4833340
静态变量 s_b 的地址为：4833344
字符串常量的地址为：4823908
全局常量 c_g_a 的地址为：4824720
全局常量 c_g_b 的地址为：4824724
字符串常量和全局常量都在常量区中，所以都是482开头
全局变量和静态变量都是483开头，与常量区离得都不远
*/
return 0;
}
可以看出来，全局常量、字符串常量都放在全局区里很近的位置，全局变量、静态变量也放在全局区，只是与全局常量、字符串常量还有一定距离，但是离得不远
局部常量与局部变量、全局变量、静态变量、字符串常量的地址比较：
// 全局变量
int g_a = 10;
int g_b = 10;
// 全局常量：const修饰的全局变量
const int c_g_a = 10;
const int c_g_b = 10;
int main() {
// 局部变量
int a = 10;
int b = 10;
// 静态变量
static int s_a = 10;
static int s_b = 10;
// 局部常量：const修饰的局部变量
const int c_l_a = 10;
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 << "静态变量 s_a 的地址：" << (int)&s_a << endl;
cout << "静态变量 s_b 的地址：" << (int)&s_b << endl;
cout << "字符串常量的地址：" << (int)&("hello world") << endl;
cout << "全局常量 c_g_a 的地址：" << (int)&c_g_a << endl;
cout << "全局常量 c_g_b 的地址：" << (int)&c_g_b << endl;
cout << "局部常量 c_l_a 的地址：" << (int)&c_l_a << endl;
cout << "局部常量 c_l_b 的地址：" << (int)&c_l_b << endl;
/*
局部变量 a 的地址为：13629316
局部变量 b 的地址为：13629304
全局变量 g_a 的地址为：15581236
全局变量 g_b 的地址为：15581240
静态变量 s_a 的地址为：15581244
静态变量 s_b 的地址为：15581248
字符串常量的地址为：15571812
全局常量 c_g_a 的地址为：15572624
全局常量 c_g_b 的地址为：15572628
局部常量 c_l_a 的地址为：13629292
局部常量 c_l_b 的地址为：13629280
有局部修饰的常量或变量，都不存放在全局区
全局区存放：全局变量、全局常量、静态变量、字符串常量
*/
return 0;
}
可以看到，局部常量并不存放在全局区，而是和局部变量存储在一块
综上，全局区里存储的数据： 全局变量、 静态变量、 全局常量、 字符串常量
不在全局区中的数据： 局部变量、 局部常量（const修饰的局部变量）
有局部两个字，就不会存放在全局区
全局区中的数据：全局变量、全局常量（const修饰的全局变量）、静态变量（static）、字符串常量
示意图：
// 全局变量 --- 全局区
int g_a = 10;
int g_b = 10;
// 全局常量：const修饰的全局变量 --- 全局区
const int c_g_a = 10;
const int c_g_b = 10;
int main() {
// 局部变量
int a = 10;
int b = 10;
// 静态变量 --- 全局区
static int s_a = 10;
static int s_b = 10;
// 局部常量：const修饰的局部变量
const int c_l_a = 10;
const int c_l_b = 10;
return 0;
}
总结：
- C++在程序运行前，分为 全局区和 代码区
- 代码区的特点是 共享和 只读
- 全局区中存放 全局变量、 静态变量、 常量（全局常量、字符串常量）
- 常量区中存放 const 修饰的 全局常量 和 *字符串常量
程序运行后
栈区
栈区：由 编译器自动分配释放，存放 函数的参数值、 局部变量等。
注意事项：不要返回局部变量的地址，栈区开辟的数据由编译器自动释放。
局部变量和形参都放在栈区
- 对于形参，在调用函数时，形参会在栈区开辟数据空间
- 对于局部变量，存放在栈区，栈区的数据在函数执行完后自动释放
定义在函数里的局部变量，在函数执行完后，会被编译器自动释放。如果我们在这个函数中返回这个局部变量的地址，那么编译器会保留一次这个地址的值，但是由于函数执行结束后，局部变量被释放，当第二次访问这个地址时，则无法访问到原本定义的值。
int * func() {
int a = 10;
return &a;
}
int main() {
int *p = func();
cout << *p << endl;
cout << *p << endl;
/*
10
2034547680 这是一个乱码
*/
return 0;
}
从输出结果可以看出，第一次对返回的指针进行解引用，还可以访问到原本的数据，但是第二次就不行了。这是因为编译器对这个数据进行了一次保留，但是由于在func函数执行完后，局部变量a已经被编译器释放，栈上的数据就清空了，再次访问这个地址只会是乱码。
所以，不要返回局部变量的地址
堆区
堆区：由 程序员分配释放，若程序员不释放，程序结束时由操作系统回收
在C++中，程序员主要利用关键字 new在堆区开辟内存
这里的数据不会一直放在内存上，在程序运行期间，如果程序员不释放，则这个数据不会被释放，当程序结束时，会由操作系统回收
程序员自己开辟的内存，是由程序员自己管理的，存放在了堆区，所以函数执行完，会把栈区清空，但是不会影响到堆区。
语法： new 数据类型(值);
返回值：这段内存的地址
用同类型的指针去接收这个返回值。
int * func() {
int a = 10; // a是局部变量，开辟在栈区，函数执行完后，被编译器释放
// 利用关键字new，将数据开辟到堆区
// new int(10);
int * p1 = new int(10); // 用指针去接收这个返回值
return p1;
}
int main() {
int * p = func();
cout << *p << endl;
cout << *p << endl;
cout << *p << endl;
/*
10
10
10
*/
return 0;
}
此处需要注意：
在func中用于接收堆区内存地址的指针p1本质上也是一个局部变量，这个指针p1是开辟在栈区的，在func函数执行完后，它也会被释放。
所以我们在调用func函数时，已经在main函数中开辟了一个新的指针p来保存这个返回值，也就是保存了堆区的地址，所以即使func函数执行完，p1被释放了，但是堆区的地址我们已经获取到了，而且函数执行完时，堆区地址是不会释放的，所以我们可以多次访问这个堆区地址，并且每次输出都是一样的值。
若func返回的是局部变量的地址，这个指针所指向的内存是栈区，函数执行完，栈区清空后，这个地址的内存被释放了，所以即使我们在main函数中获取了这个地址也没用，编译器只会保留一次数据，第二次访问时就找不到这个数据了，已经被清空了。
new操作符
C++中利用new操作符在 堆区开辟数据，利用delete操作符在堆区释放数据
若开辟一个变量，语法： new 数据类型()
若开辟一个数组，语法： new 数据类型[数组长度]
利用new创建的数据，会返回该数据对应类型的指针，也就是存放在堆区的地址
堆区开辟的数据，由程序员手动开辟，手动释放，释放利用操作符 delete
释放单个变量，语法： delete 变量地址
释放数组，语法： delete[] 数组名
int * func() {
// 在堆区创建整型数据
// new返回的是该数据类型的指针，也是这块内存的地址
int * p = new int(10);
return p;
}
void test01() {
int * p = func();
cout << *p << endl; // 程序员释放前
delete p; // 释放内存
// cout << *p << endl; // 程序员释放后
// 内存已被释放，再次访问就是非法操作，会报错
}
// 在堆区利用new开辟数组
void test02() {
// 在堆区，创建10个整型数据的数组
int * arr = new int[10]; // 10代表数组有10个元素
for (int i = 0; i < 10; i ++) {
arr[i] = i;
}
for (int i = 0; i < 10; i ++) {
cout << arr[i] << endl;
}
delete[] arr;
}
int main() {
test01();
test02();
return 0;
}
12行代码报错如下：
属于是非法访问。
Original: https://www.cnblogs.com/seansheep/p/15968996.html
Author: 在青青草原上抓羊
Title: 【C++基础】内存分区模型
原创文章受到原创版权保护。转载请注明出处：https://www.johngo689.com/608959/
转载文章受原作者版权保护。转载请注明原作者出处！