内存分区模型

1.内存分区模型

C++在执行时，将内存方向大致分为4个区域

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

• • 用户写的所有代码存放的地方

• 全局区：存放全局变量和静态变量以及常量
• 栈区：由编译器自动分配和释放，存放函数的参数值，局部变量
• 堆区：由程序员分配和释放，若程序员不释放，程序结束时由操作系统回收

划分区域的目的是什么：

不同区域存放的数据，赋予不同的生命周期，给我们更大的灵活编程

2.在程序运行之前分配的区域

程序编译后 ，生成了exe可执行程序，未执行该程序之前分为两个区域

2.1代码区

存放CPU执行机器指令

代码区是共享的，针对频繁执行的程序， 提高内存使用效率

代码区是只读的，防止指令被意外修改，导致程序功能的改变

2.2全局区

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

生命周期由操作系统管理

局部变量

#include<iostream>
#include<cstdio>
#include<stdint.h>
using namespace std;

int main()
{
    int  a=10;
    int  b=10;
    uintptr_t addr_a = reinterpret_cast<uintptr_t>(&a);
    uintptr_t addr_b = reinterpret_cast<uintptr_t>(&b);
    printf("%lu\n", addr_a);
    printf("%lu\n", addr_b);

    return 0;
}

局部变量位于栈区

全局变量

在函数体之外

#include<iostream>
#include<cstdio>
#include<stdint.h>
using namespace std;
//全局变量 e f
int  e=10;
int  f=10;
int main()
{

     int  a=10;
     int  b=10;
     int  c=10;
     int  d=10;
   //局部变量
    uintptr_t addr_a = reinterpret_cast<uintptr_t>(&a);
    uintptr_t addr_b = reinterpret_cast<uintptr_t>(&b);
    uintptr_t addr_c = reinterpret_cast<uintptr_t>(&c);
    uintptr_t addr_d = reinterpret_cast<uintptr_t>(&d);
    printf("局部变量a:%lu\n", addr_a);
    printf("局部变量b:%lu\n", addr_b);
    printf("局部变量c:%lu\n", addr_c);
    printf("局部变量d:%lu\n", addr_d);
    //全局变量
    uintptr_t addr_e = reinterpret_cast<uintptr_t>(&e);
    uintptr_t addr_f = reinterpret_cast<uintptr_t>(&f);
    printf("全局变量e:%lu\n", addr_e);
    printf("全局变量f:%lu\n", addr_f);

    return 0;
}

可以看到全局变量和局部变量处于不同的地址空间范围内

静态变量

在普通变量前面加“static”关键字就是静态变量

#include<iostream>
#include<cstdio>
#include<stdint.h>
using namespace std;
//全局变量 e f
int  e=10;
int  f=10;
int main()
{
   //局部变量
     int  a=10;
     int  b=10;
     int  c=10;
     int  d=10;
    uintptr_t addr_a = reinterpret_cast<uintptr_t>(&a);
    uintptr_t addr_b = reinterpret_cast<uintptr_t>(&b);
    uintptr_t addr_c = reinterpret_cast<uintptr_t>(&c);
    uintptr_t addr_d = reinterpret_cast<uintptr_t>(&d);
    printf("局部变量a:%lu\n", addr_a);
    printf("局部变量b:%lu\n", addr_b);
    printf("局部变量c:%lu\n", addr_c);
    printf("局部变量d:%lu\n", addr_d);
     //静态变量
     static int g=10;
     static int h=10;
    uintptr_t addr_g = reinterpret_cast<uintptr_t>(&g);
    uintptr_t addr_h = reinterpret_cast<uintptr_t>(&h);
    printf("静态变量g:%lu\n", addr_g);
    printf("静态变量h:%lu\n", addr_h);
    //全局变量
    uintptr_t addr_e = reinterpret_cast<uintptr_t>(&e);
    uintptr_t addr_f = reinterpret_cast<uintptr_t>(&f);
    printf("全局变量e:%lu\n", addr_e);
    printf("全局变量f:%lu\n", addr_f);

    return 0;
}

可以看到全局变量和静态变量处于同一区域

常量

字符串常量

#include<iostream>
#include<cstdio>
#include<stdint.h>
using namespace std;
//全局变量 e f
int  e=10;
int  f=10;
int main()
{
   //局部变量
     int  a=10;
     int  b=10;
     int  c=10;
     int  d=10;
    uintptr_t addr_a = reinterpret_cast<uintptr_t>(&a);
    uintptr_t addr_b = reinterpret_cast<uintptr_t>(&b);
    uintptr_t addr_c = reinterpret_cast<uintptr_t>(&c);
    uintptr_t addr_d = reinterpret_cast<uintptr_t>(&d);
    printf("局部变量a:%lu\n", addr_a);
    printf("局部变量b:%lu\n", addr_b);
    printf("局部变量c:%lu\n", addr_c);
    printf("局部变量d:%lu\n", addr_d);
     //静态变量
     static int g=10;
     static int h=10;
    uintptr_t addr_g = reinterpret_cast<uintptr_t>(&g);
    uintptr_t addr_h = reinterpret_cast<uintptr_t>(&h);
    printf("静态变量g:%lu\n", addr_g);
    printf("静态变量h:%lu\n", addr_h);
    //全局变量
    uintptr_t addr_e = reinterpret_cast<uintptr_t>(&e);
    uintptr_t addr_f = reinterpret_cast<uintptr_t>(&f);
    printf("全局变量e:%lu\n", addr_e);
    printf("全局变量f:%lu\n", addr_f);
    //字符串常量
    uintptr_t addr_s = reinterpret_cast<uintptr_t>(&"hello");
    printf("字符串常量s:%lu\n", addr_s);
    return 0;
}

const修饰的变量

1.const修饰的全局变量

#include<iostream>
#include<cstdio>
#include<stdint.h>
using namespace std;
//全局变量 e f
int  e=10;
//const修饰的全局变量——全局常量
const int  f=10;



int main()
{
   //局部变量
     int  a=10;
     int  b=10;
     int  c=10;
     int  d=10;
    uintptr_t addr_a = reinterpret_cast<uintptr_t>(&a);
    uintptr_t addr_b = reinterpret_cast<uintptr_t>(&b);
    uintptr_t addr_c = reinterpret_cast<uintptr_t>(&c);
    uintptr_t addr_d = reinterpret_cast<uintptr_t>(&d);
    printf("局部变量a:%lu\n", addr_a);
    printf("局部变量b:%lu\n", addr_b);
    printf("局部变量c:%lu\n", addr_c);
    printf("局部变量d:%lu\n", addr_d);
     //静态变量
     static int g=10;
     static int h=10;
    uintptr_t addr_g = reinterpret_cast<uintptr_t>(&g);
    uintptr_t addr_h = reinterpret_cast<uintptr_t>(&h);
    printf("静态变量g:%lu\n", addr_g);
    printf("静态变量h:%lu\n", addr_h);
    //全局变量
    uintptr_t addr_e = reinterpret_cast<uintptr_t>(&e);
    printf("全局变量e:%lu\n", addr_e);
    //全局常量
    uintptr_t addr_f = reinterpret_cast<uintptr_t>(&f);
    printf("全局常量f:%lu\n", addr_f);

      //字符串常量
    uintptr_t addr_s = reinterpret_cast<uintptr_t>(&"hello");
    printf("字符串常量s:%lu\n", addr_s);
    return 0;
}

2.const修饰的局部变量

#include<iostream>
#include<cstdio>
#include<stdint.h>
using namespace std;
//全局变量 e f
int  e=10;
//const修饰的全局变量——全局常量
const int  f=10;



int main()
{
   //局部变量
     int  a=10;
     int  b=10;
    uintptr_t addr_a = reinterpret_cast<uintptr_t>(&a);
    uintptr_t addr_b = reinterpret_cast<uintptr_t>(&b);
    printf("局部变量a:%lu\n", addr_a);
    printf("局部变量b:%lu\n", addr_b);

    //局部常量
     const int  c=10;
     const int  d=10;
    uintptr_t addr_c = reinterpret_cast<uintptr_t>(&c);
    uintptr_t addr_d = reinterpret_cast<uintptr_t>(&d);
    printf("局部常量c:%lu\n", addr_c);
    printf("局部常量d:%lu\n", addr_d);
     //静态变量
     static int g=10;
     static int h=10;
    uintptr_t addr_g = reinterpret_cast<uintptr_t>(&g);
    uintptr_t addr_h = reinterpret_cast<uintptr_t>(&h);
    printf("静态变量g:%lu\n", addr_g);
    printf("静态变量h:%lu\n", addr_h);
    //全局变量
    uintptr_t addr_e = reinterpret_cast<uintptr_t>(&e);
    printf("全局变量e:%lu\n", addr_e);
    //全局常量
    uintptr_t addr_f = reinterpret_cast<uintptr_t>(&f);
    printf("全局常量f:%lu\n", addr_f);

      //字符串常量
    uintptr_t addr_s = reinterpret_cast<uintptr_t>(&"hello");
    printf("字符串常量s:%lu\n", addr_s);
    return 0;
}

局部变量与局部常量都不处于全局区

3.程序运行之后的区域

3.1栈区

生长方向：由高地址向低地址方向生长

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

注：不要返回局部变量的地址

3.2堆区

生长方向：由低地址向高地址方向生长

一般由程序员分配释放（动态内存申请和释放），若程序员没有手动释放，在程序结束时空间由操作系统回收。