C语言中程序内存的各种变量存储区域的理解

最新推荐文章于 2021-05-18 03:22:44 发布

lee_824

最新推荐文章于 2021-05-18 03:22:44 发布

阅读量1.6k

点赞数 3

文章标签： c语言堆栈 stm32

本文链接：https://blog.csdn.net/lee_goi/article/details/110207011

版权

摘要：

这次我将总结一下我学习的C语言种存储内存的各种变量存储区域，通过Ubuntu和Keil及串口来演示。从中更加熟悉存储区域

文章目录

✍️ 简单介绍

📝 1、内存分配方式

**静态存储区域分配。**内存在程序编译的时候就已经分配好，这块内存在程序的整个运行期间都存在。例如全局变量，static变量。
**在栈上创建。**在执行函数时，函数内局部变量的存储单元都可以在栈上创建，函数执行结束时这些存储单元自动被释放。栈内存分配运算内置于处理器的指令集中，效率很高，但是分配的内存容量有限。
从堆上分配，亦称动态内存分配。程序在运行的时候用malloc或new申请任意多少的内存，程序员自己负责在何时用free或delete释放内存。动态内存的生存期由程序员决定，使用非常灵活，但如果在堆上分配了空间，就有责任回收它，否则运行的程序会出现内存泄漏，频繁地分配和释放不同大小的堆空间将会产生堆内碎块。

📝 2、程序的内存空间

C语言在内存中一共分为如下几个区域，分别是：

内存栈区：存放局部变量名；
内存堆区：存放new或者malloc出来的对象；
常数区：存放局部变量或者全局变量的值；
静态区：用于存放全局变量或者静态变量；
代码区：存放函数体的二进制代码。

📝 3、区域的简单解释

栈区(stack)–由编译器自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。

堆区(heap)–般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。注意它与数据结构中的堆是两回事，分配方式类似于链表。

全局区(静态区)(static)–全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域（RW），未初始化的全局变量和未初始化的静态变量在相邻的另一块区域（ZI）。程序结束后有系统释放

文字常量区–常量字符串就是放在这里的。程序结束后由系统释放（RO）

程序代码区–存放函数体的二进制代码。（RO）

📝 4、动态内存与静态内存

静态分配内存：是在程序编译和链接时就确定好的内存。
动态分配内存：是在程序加载、调入、执行的时候分配/回收的内存。

📝 5、堆栈

堆和栈都是动态分配内存，两者空间大小都是可变的。

Stack： 栈，存放Automatic Variables，按内存地址由高到低方向生长，其最大大小由编译时确定，速度快，但自由性差，最大空间不大。

通常是用于那些在编译期间就能确定存储大小的变量的存储区，用于在函数作用域内创建，在离开作用域后自动销毁的变量的存储区。通常是局部变量，函数参数等的存储区。他的存储空间是连续的，两个紧密挨着定义的局部变量，他们的存储空间也是紧挨着的。栈的大小是有限的。
Heap： 堆，自由申请的空间，按内存地址由低到高方向生长，其大小由系统内存/虚拟内存上限决定，速度较慢，但自由性大，可用空间大。

通常是用于那些在编译期间不能确定存储大小的变量的存储区，它的存储空间是不连续的，一般由==malloc（或new）函数来分配内存块，并且需要用free（delete）==函数释放内存。如果程序员没有释放掉，那么就会出现常说的内存泄漏问题。需要注意的是，两个紧挨着定义的指针变量，所指向的malloc出来的两块内存并不一定的是紧挨着的=，所以会产生内存碎片。另外需要注意的一点是，堆的大小几乎不受限制，理论上每个程序最大可达4GB。
每个线程都会有自己的栈，但是堆空间是共用的。

📝 6、全局/静态存储区

和“栈”一样，通常是用于那些在编译期间就能确定存储大小的变量的存储区，但它用于的是在整个程序运行期间都可见的全局变量和静态变量。

📝 7、常量存储区

和“全局/静态存储区”一样，通常是用于那些在编译期间就能确定存储大小的常量的存储区，并且在程序运行期间，存储区内的常量是全局可见的。这是一块比较特殊的存储去，他们里面存放的是常量，不允许被修改。

注意：

1）堆向高内存地址生长；

2）栈向低内存地址生长；

3）堆和栈相向而生，堆和栈之间有个临界点，称为stkbrk。

注意：

随着函数调用层数的增加，函数栈帧是一块块地向内存低地址方向延伸的；
随着进程中函数调用层数的减少（即各函数调用的返回），栈帧会一块块地被遗弃而向内存的高址方向回缩；
各函数的栈帧大小随着函数的性质的不同而不等, 由函数的局部变量的数目决定。
未初始化数据区(BSS)：用于存放程序的静态变量，这部分内存都是被初始化为零的；而初始化数据区用于存放可执行文件里的初始化数据。这两个区统称为数据区。
Text(代码区)：是个只读区，存放了程序的代码。任何尝试对该区的写操作会导致段违法出错。代码区是被多个运行该可执行文件的进程所共享的。
进程对内存的动态申请是发生在Heap(堆)里的。随着系统动态分配给进程的内存数量的增加，Heap(堆)有可能向高址或低址延伸, 这依赖于不同CPU的实现，但一般来说是向内存的高地址方向增长的。
在未初始化数据区（BSS）或者Stack(栈区)的增长耗尽了系统分配给进程的自由内存的情况下，进程将会被阻塞, 重新被操作系统用更大的内存模块来调度运行。
函数的栈帧：包含了函数的参数(至于被调用函数的参数是放在调用函数的栈帧还是被调用函数栈帧, 则依赖于不同系统的实现)。函数的栈帧中的局部变量以及恢复该函数的主调函数的栈帧(即前一个栈帧)所需要的数据, 包含了主调函数的下一条执行指令的地址。

✍️ Ubuntu环境下程序调试

📝 1、插入代码1

#include <stdio.h>
#include <string.h>
#include <stdlib.h>
 
void before()
{
 
}
 
char g_buf[16];
char g_buf2[16];
char g_buf3[16];
char g_buf4[16];
char g_i_buf[]="123";
char g_i_buf2[]="123";
char g_i_buf3[]="123";
 
void after()
{
 
}
 
int main(int argc, char **argv)
{
        char l_buf[16];
        char l_buf2[16];
        char l_buf3[16];
        static char s_buf[16];
        static char s_buf2[16];
        static char s_buf3[16];
        char *p_buf;
        char *p_buf2;
        char *p_buf3;
 
        p_buf = (char *)malloc(sizeof(char) * 16);
        p_buf2 = (char *)malloc(sizeof(char) * 16);
        p_buf3 = (char *)malloc(sizeof(char) * 16);
 
        printf("g_buf: 0x%x\n", g_buf);
        printf("g_buf2: 0x%x\n", g_buf2);
        printf("g_buf3: 0x%x\n", g_buf3);
        printf("g_buf4: 0x%x\n", g_buf4);
 
        printf("g_i_buf: 0x%x\n", g_i_buf);
        printf("g_i_buf2: 0x%x\n", g_i_buf2);
        printf("g_i_buf3: 0x%x\n", g_i_buf3);
 
        printf("l_buf: 0x%x\n", l_buf);
        printf("l_buf2: 0x%x\n", l_buf2);
        printf("l_buf3: 0x%x\n", l_buf3);
 
        printf("s_buf: 0x%x\n", s_buf);
        printf("s_buf2: 0x%x\n", s_buf2);
        printf("s_buf3: 0x%x\n", s_buf3);
 
        printf("p_buf: 0x%x\n", p_buf);
        printf("p_buf2: 0x%x\n", p_buf2);
        printf("p_buf3: 0x%x\n", p_buf3);
 
        printf("before: 0x%x\n", before);
        printf("after: 0x%x\n", after);
        printf("main: 0x%x\n", main);
 
        if (argc > 1)
        {
                strcpy(l_buf, argv[1]);
        }
        return 0;
}

分析代码：

l_buf/l_buf2/l_buf3 ，直接定义，是由编译器自动分配的，存储在栈中

s_buf/s_buf2/s_buf3，定义static，编译器编译时分配内存。为全局变量，在全局初始化区

p_buf/p_buf2/p_buf3，定义指针变量，存储在栈中

p_buf/p_buf2/p_buf3他们指向的空间，通过malloc申请空间，存放在堆中

g_buf/g_buf2/g_buf3/g_buf4/，定义的为全局变量，在全局初始化区

📝 2、代码1执行结果：

📝 3、插入代码2

#include <stdio.h>
#include <stdlib.h>
//定义全局变量
int init_global_a = 1;
int uninit_global_a;
static int inits_global_b = 2;
static int uninits_global_b;
void output(int a)
{
	printf("hello");
	printf("%d",a);
	printf("\n");
}

int main( )
{   
	//定义局部变量
	int a=2;
	static int inits_local_c=2, uninits_local_c;
    int init_local_d = 1;
    output(a);
    char *p;
    char str[10] = "lyy";
    //定义常量字符串
    char *var1 = "1234567890";
    char *var2 = "qwertyuiop";
    //动态分配
    int *p1=malloc(4);
    int *p2=malloc(4);
    //释放
    free(p1);
    free(p2);
    printf("栈区-变量地址\n");
    printf("                a：%p\n", &a);
    printf("                init_local_d：%p\n", &init_local_d);
    printf("                p：%p\n", &p);
    printf("              str：%p\n", str);
    printf("\n堆区-动态申请地址\n");
    printf("                   %p\n", p1);
    printf("                   %p\n", p2);
    printf("\n全局区-全局变量和静态变量\n");
    printf("\n.bss段\n");
    printf("全局外部无初值 uninit_global_a：%p\n", &uninit_global_a);
    printf("静态外部无初值 uninits_global_b：%p\n", &uninits_global_b);
    printf("静态内部无初值 uninits_local_c：%p\n", &uninits_local_c);
    printf("\n.data段\n");
    printf("全局外部有初值 init_global_a：%p\n", &init_global_a);
    printf("静态外部有初值 inits_global_b：%p\n", &inits_global_b);
    printf("静态内部有初值 inits_local_c：%p\n", &inits_local_c);
    printf("\n文字常量区\n");
    printf("文字常量地址     ：%p\n",var1);
    printf("文字常量地址     ：%p\n",var2);
    printf("\n代码区\n");
    printf("程序区地址       ：%p\n",&main);
    printf("函数地址         ：%p\n",&output);
    return 0;
}

📝 4、代码2执行结果
在这里插入图片描述

📝 3、结果解释

通过运行结果可以发现，Ubuntu在栈区和堆区的地址值都是从上到下依次增大的

✍️ Keil下程序调试,并输出上位机上验证

总的来说可以归结为下表

内存高地址	栈区
	堆区
	.bss段
	.data段
	常量区
内存低地址	代码区

Keil下Code、RO-data、RW-data、ZI-data 这几个段

Code是存储程序代码的；

RO-data是存储const常量和指令

RW-data是存储初始化值不为0的全局变量

ZI-data是存储未初始化的全局变量或初始化值为0的全局变量

**Flash=Code + RO Data + RW Data;**

**RAM= RW-data+ZI-data;**

这个是 MDK 编译之后能够得到的每个段的大小，也就能得到占用相应的FLASH和RAM的大小，但是还有两个数据段也会占用RAM，但是是在程序运行的时候，才会占用，那就是堆和栈。

在stm32的启动文件.s文件里面，就有堆栈的设置，其实这个堆栈的内存占用就是在上面RAM分配给RW-data+ZI-data之后的地址开始分配的。

测试把变量分开

赋值的全局变量data段
未赋值的bsss段
常量rodata段

把他们的地址都发给上位机

程序测试

#include "led.h"
#include "delay.h"
#include "key.h"
#include "sys.h"
#include "usart.h"
#include "beep.h"
static unsigned int val1 = 1;        //data段
unsigned int val2 = 1;               //初始化的全局变量data段
unsigned int val3 ;                  //未初始的在bsss段
const unsigned int val4 = 1;         //常量在rodata段，只读
unsigned char Demo(unsigned int num)
{
	char var;               //栈区，123456，存放在常量区
	unsigned int num1=1;            //栈区
  static unsigned int num2=0;      //,data段
  const unsigned int num3 =7;       //栈区
	printf("val1:	0x%x\r\n",&val1);
	printf("val2:	0x%x\r\n",&val2);
	printf("val3:	0x%x\r\n",&val3);
	printf("val4:	0x%x\r\n",&val4);
	printf("var:	0x%x\r\n",&var);
	printf("num1:	0x%x\r\n",&num1);
	printf("num2	0x%x\r\n",&num2);
	printf("num3:	0x%x\r\n",&num3);
	return 1;
}
int main(void)
{		
	unsigned int num=0;
	BEEP_Init();				//初始化蜂鸣器不响
	NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); //设置NVIC中断分组2:2位抢占优先级，2位响应优先级
	uart_init(115200);	 //串口初始化为115200          
	num = Demo(num); //返回值存放在栈区
}

经过Keil编译并build可以看到下面图

存放了Code、RO-data、RW-data、ZI-data四个代码段的大小。

其中Code就是代码占用大小，RO-data是只读常量、RW-data是已初始化的可读可写变量，ZI-data是未初始化的可读可写变量。

通过调试找出各个地址

直接查看就好（由于和后面串口发送的一样就不再列出）

经过串口发送后得到变量地址

打开上位机显示后如下：

查看STM32地址分配
在这里插入图片描述

ROM的地址分配是从0x8000000开始，整个大小为0x80000，这个部分用于存放代码区和文字常量区。RAM的地址分配是从0x20000000开始，其大小是0x10000，这个区域用来存放栈、堆、全局区（.bss段、.data段）。与代码结果显示进行对比，也可以看出对应得部分得地址与设置的是相对应的。