- 一、题目要求
- 二、全局变量 & 局部变量
- 三、堆 & 栈
- 1、STM32中的堆栈
- 2、程序的内存分配
- 3、各区存放位置
- RAM
- ROM
- Flash Memory
- 不同数据的存放位置
- Keil中的Build Output窗口
- 4、关于堆(stack)和栈(heap)详细比较
- 申请方式
- 申请和系统的响应
- 申请大小的限制
- 申请效率的比较
- 堆和栈中的存储内容
- 通俗解释
- 四、Ubuntu(x86)系统和STM32(Keil)中编程验证
- 1、代码撰写
- 2、Ubuntu运行
- 3、Keil运行
- keil 环境下默认的内存配置说明
- 实际运行情况
- 4、结果分析（仍在思考ing）
- 五、总结
一、题目要求
编写一个C程序，重温全局变量、局部变量、堆、栈等概念，在Ubuntu(x86)系统和STM32(Keil)中分别进行编程、验证（STM32 通过串口printf 信息到上位机串口助手) 。
归纳出Ubuntu、stm32下的C程序中堆、栈、全局、局部等变量的分配地址，进行对比分析。
全局变量
在所有函数外部定义的变量称为全局变量（Global Variable），它的作用域默认是整个程序，也就是所有的源文件。
局部变量
定义在函数内部的变量称为局部变量（Local Variable），它的作用域仅限于函数内部， 离开该函数的内部就是无效的，再使用就会报错。
二者之间的区别
单片机是一种集成电路芯片，集成CPU、RAM、ROM、多种I/O口和中断系统、定时器/计数器等功能。CPU中包括了各种总线电路，计算电路，逻辑电路，还有各种寄存器。
stm32 有通用寄存器 R0‐ R15 以及一些特殊功能寄存器，其中包括了堆栈指针寄存器。
当stm32正常运行程序的时候，来了一个中断，CPU就需要将寄存器中的值压栈到RAM里，然后将数据所在的地址存放在堆栈寄存器中。
等中断处理完成退出时，再将数据出栈到之前的寄存器中，这个在C语言里是自动完成的。
一般程序占用的内存分为以下几个部分：
1、栈区（stack）— 由编译器自动分配释放 ，存放函数的参数值，局部变量的值等。其 *** 作方式类似于数据结构中的栈。
2、堆区（heap） — 一般由程序员分配释放， 若程序员不释放，程序结束时可能由OS回收。它与数据结构中的堆是两回事，分配方式类似于链表。
3、全局区（静态区）（static）—，全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域， 未初始化的全局变量和未初始化的静态变量在相邻的另一块区域。 程序结束后有系统释放
4、文字常量区—常量字符串就是放在这里的。 程序结束后由系统释放
5、程序代码区—存放函数体的二进制代码。
示例程序
//main.cpp
int a = 0; //全局初始化区
int a = 0; //全局初始化区
char *p1; //全局未初始化区
main() {
int b; //栈
char s[] = "abc"; //栈
char *p2; //栈
char *p3 = "123456"; //123456在常量区，p3在栈上。
static int c = 0; //全局（静态）初始化区
p1 = (char *)malloc(10);
p2 = (char *)malloc(20);
//分配得来得10和20字节的区域就在堆区。
strcpy(p1, "123456"); //123456放在常量区，编译器可能会将它与p3所指向的"123456"优化成一个地方。
}
在一个STM32程序代码中，从内存高地址到内存低地址，依次分布着栈区、堆区、全局区（静态区）、常量去、代码区，其中全局区中高地址分布着.bss段，低地址分布着.data段。
通过下面的思维导图对这部分内容进行详细的介绍：
通过下面的程序，对上述介绍进行更具体的解释：
#include3、各区存放位置static unsigned int val1 = 1; //val1存放在.data段 unsigned int val2 = 1; //初始化的全局变量存放在.data段 unsigned int val3 ; //未初始化的全局变量存放在.bss段 const unsigned int val4 = 1; //val4存放在.rodata（只读数据段） unsigned char Demo(unsigned int num) // num 存放在栈区 { char var = "123456"; // var存放在栈区，"123456"存放在常量区 unsigned int num1 = 1 ; // num1存放在栈区 static unsigned int num2 = 0; // num2存放在.data段 const unsigned int num3 = 7; //num3存放在栈区 void *p; p = malloc(8); //p存放在堆区 free(p); return 1; } void main() { unsigned int num = 0 ; num = Demo(num); //Demo()函数的返回值存放在栈区。 }
下面对这些区存放在哪种介质上进行讨论。
首先，我们需要明白RAM和ROM、Flash Memory的物理特性
RAMRAM又称随机存取存储器，存储的内容可通过指令随机读写访问。RAM中的存储的数据在掉电是是会丢失，因而只能在开机运行时存储数据。其中RAM又可以分为两种，一种是Dynamic RAM(DRAM动态随机存储器),另一种是Static RAM(SRAM,静态随机存储器)。
ROMROM又称只读存储器，只能从里面读出数据而不能任意写入数据。ROM与RAM相比,具有价格高,容量小的缺点。但由于其具有掉电后数据可保持不变的优点，因此常用也存放一次性写入的程序和数据，比如主版的BIOS程序的芯片就是ROM存储器。
Flash Memory由于ROM具有不易更改的特性，后面就发展了Flash Memory。Flash Memory不仅具有ROM掉电不丢失数据的特点，又可以在需要的时候对数据进行更改，不过价格比ROM要高。
不同数据的存放位置由前面的分析我们知道，代码区和常量区的内容是不允许被修改的，ROM（STM32就是Flash Memory）也是不允许被修改的，所以代码区和常量区的内容编译后存储在ROM中。
栈、堆、全局区（.bss段、.data段）都是存放在RAM中。
Keil中的Build Output窗口C 语言上分为栈、堆、bss、data、code段；
MDK 下分为：Code、RO-data、RW-data、ZI-data 这几个段。
任意在Keil中编译一个文件
编译后，我们可以看到存在Code、RO-data、RW-data、ZI-data四个代码段大小
其中Code是代码占用大小，RO-data是只读常量、RW-data是已初始化的可读可写变量，ZI-data是未初始化的可读可写变量。
有些时候，我们需要知道RAM和ROM的使用情况如何，那么我们就可以使用下面的公式计算。
RAM = RW-data + ZI-data
ROM = Code + RO-data + RW-data
Flash=Code + RO Data + RW Data
这个是 MDK 编译之后能够得到的每个段的大小，也就能得到占用相应的FLASH和RAM的大小，但是还有两个数据段也会占用RAM，但是是在程序运行的时候，才会占用，那就是堆和栈。
在stm32的启动文件.s文件里面，就有堆栈的设置，其实这个堆栈的内存占用就是在上面RAM分配给RW-data+ZI-data之后的地址开始分配的。
堆 是编译器调用动态内存分配的内存区域；
栈 是程序运行的时候局部变量的地方，所以局部变量用数组太大了都有可能造成栈溢出。
堆栈的大小在编译器编译之后是不知道的，只有运行的时候才知道，所以需要注意不要造成堆栈溢出，会出现 hardfault 问题。
4、关于堆(stack)和栈(heap)详细比较 申请方式堆：
由系统自动分配。 例如，声明在函数中一个局部变量 int b; 系统自动在栈中为b开辟空间
栈：
需要程序员自己申请，并指明大小，在c中malloc函数，如p1 = (char *)malloc(10)，在C++中用new运算符。
栈：
只要栈的剩余空间大于所申请空间，系统将为程序提供内存，否则将报异常提示栈溢出。
堆：
首先应该知道 *** 作系统有一个记录空闲内存地址的链表，当系统收到程序的申请时，会遍历该链表，寻找第一个空间大于所申请空间的堆结点，然后将该结点从空闲结点链表中删除，并将该结点的空间分配给程序，另外，对于大多数系统，会在这块内存空间中的首地址处记录本次分配的大小，这样，代码中的delete语句才能正确的释放本内存空间。另外，由于找到的堆结点的大小不一定正好等于申请的大小，系统会自动的将多余的那部分重新放入空闲链表中。
栈：
在Windows下,栈是向低地址扩展的数据结构，是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的，在WINDOWS下，栈的大小是2M（也有的说是1M，总之是一个编译时就确定的常数），如果申请的空间超过栈的剩余空间时，将提示overflow。因此，能从栈获得的空间较小。
堆：
堆是向高地址扩展的数据结构，是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见，堆获得的空间比较灵活，也比较大。
栈：
由系统自动分配，速度较快。但程序员是无法控制的。
堆：
是由new分配的内存，一般速度比较慢，而且容易产生内存碎片,不过用起来最方便。
另外，在WINDOWS下，最好的方式是用VirtualAlloc分配内存，他不是在堆，也不是在栈是直接在进程的地址空间中保留一快内存，虽然用起来最不方便。但是速度快，也最灵活。
栈：
在函数调用时，第一个进栈的是主函数中后的下一条指令（函数调用语句的下一条可执行语句）的地址，然后是函数的各个参数，在大多数的C编译器中，参数是由右往左入栈的，然后是函数中的局部变量。注意静态变量是不入栈的。
当本次函数调用结束后，局部变量先出栈，然后是参数，最后栈顶指针指向最开始存的地址，也就是主函数中的下一条指令，程序由该点继续运行。
堆：
一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容有程序员安排。
使用栈就象我们去饭馆里吃饭，只管点菜（发出申请）、付钱、和吃（使用），吃饱了就走，不必理会切菜、洗菜等准备工作和洗碗、刷锅等扫尾工作，他的好处是快捷，但是自由度小。
使用堆就像是自己动手做喜欢吃的菜肴，比较麻烦，但是比较符合自己的口味，而且自由度大。
#include2、Ubuntu运行#include //定义全局变量 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] = "yaoyao";//栈 //定义常量字符串 char *var1 = "1234567890"; char *var2 = "abcdefghij"; //动态分配——堆区 int *p1=malloc(4); int *p2=malloc(4); //释放 free(p1); free(p2); printf("栈区-变量地址n"); printf(" a：%pn", &a); printf(" init_local_d：%pn", &init_local_d); printf(" p：%pn", &p); printf(" str：%pn", str); printf("n堆区-动态申请地址n"); printf(" %pn", p1); printf(" %pn", p2); printf("n全局区-全局变量和静态变量n"); printf("n.bss段n"); printf("全局外部无初值 uninit_global_a：%pn", &uninit_global_a); printf("静态外部无初值 uninits_global_b：%pn", &uninits_global_b); printf("静态内部无初值 uninits_local_c：%pn", &uninits_local_c); printf("n.data段n"); printf("全局外部有初值 init_global_a：%pn", &init_global_a); printf("静态外部有初值 inits_global_b：%pn", &inits_global_b); printf("静态内部有初值 inits_local_c：%pn", &inits_local_c); printf("n文字常量区n"); printf("文字常量地址 ：%pn",var1); printf("文字常量地址 ：%pn",var2); printf("n代码区n"); printf("程序区地址 ：%pn",&main); printf("函数地址 ：%pn",&output); return 0; }
将上面的代码放入nano文本编辑器中，进行编译
可以发现，Ubuntu在栈区和堆区的地址值都是从上到下增长的。
3、Keil运行 keil 环境下默认的内存配置说明实际运行情况① 默认分配的ROM区域是0x8000000开始，大小是0x80000的一片区域，那么这篇区域是只读区域，不可修改，也就是存放的代码区和常量区
② 默认分配的RAM区域是0x20000000开始，大小是0x10000的一片区域，这篇区域是可读写区域，存放的是静态区、栈区和堆区。
在工程中进行串口初始化
可以参考博客【嵌入式09】STM32串口通信，发送Hello Windows示例
修改主函数
#include "led.h" #include "delay.h" #include "key.h" #include "sys.h" #include "usart.h" #include#include //定义全局变量 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(void) { u16 t; u16 len; u16 times=0; delay_init(); //延时函数初始化 NVIC_PriorityGroupConfig(NVIC_PriorityGroup_2); //设置NVIC中断分组2:2位抢占优先级，2位响应优先级 uart_init(115200); //串口初始化为115200 LED_Init(); //LED端口初始化 KEY_Init(); //初始化与按键连接的硬件接口 while(1) { //定义局部变量 int a=2; static int inits_local_c=2, uninits_local_c; int init_local_d = 1; output(a); char *p; char str[10] = "yaoyao"; //定义常量字符串 char *var1 = "1234567890"; char *var2 = "abcdefghij"; //动态分配 int *p1=malloc(4); int *p2=malloc(4); //释放 free(p1); free(p2); printf("栈区-变量地址n"); printf(" a：%pn", &a); printf(" init_local_d：%pn", &init_local_d); printf(" p：%pn", &p); printf(" str：%pn", str); printf("n堆区-动态申请地址n"); printf(" %pn", p1); printf(" %pn", p2); printf("n全局区-全局变量和静态变量n"); printf("n.bss段n"); printf("全局外部无初值 uninit_global_a：%pn", &uninit_global_a); printf("静态外部无初值 uninits_global_b：%pn", &uninits_global_b); printf("静态内部无初值 uninits_local_c：%pn", &uninits_local_c); printf("n.data段n"); printf("全局外部有初值 init_global_a：%pn", &init_global_a); printf("静态外部有初值 inits_global_b：%pn", &inits_global_b); printf("静态内部有初值 inits_local_c：%pn", &inits_local_c); printf("n文字常量区n"); printf("文字常量地址 ：%pn",var1); printf("文字常量地址 ：%pn",var2); printf("n代码区n"); printf("程序区地址 ：%pn",&main); printf("函数地址 ：%pn",&output); return 0; } }
编译，发现报错
编译出现：error: declaration may not appear after executable statement in block
查阅资料了解到：
声明不能出现在可执行状态之后，C语言关于变量的定义只能放在函数的开头，放在执行语句的前面定义，这是C89的标准。
后来的C99标准就已经改变了，无论定义在之前还是之后都是可以的。
点击魔术棒，再点c/c++，打钩上C99 mode 即可
重新编译后仍然报错
编译出现：Library reports error: __use_no_semihosting was requested, but _ttywrch was referenced
解决方法：使用微库
再次编译，成功！
将代码烧录进入芯片
按下reset键，单片机发送数据
用SSCOM和XCOM串口助手显示不好看，于是用野火串口试了一下
可以发现，stm32的栈区的地址值是从上到下减小的，堆区则是从上到下增长的。
一般而言，程序内变量在堆栈上的分配，栈是由高地址到低地址，堆是由低地址到高地址。
在Ubuntu下，栈区的地址存储是向上增长，堆区的地址存储也是向上增长；
在STM32下，栈区的地址存储是向下增长，堆区的地址存储却是向上增长。
可是为什么Ubuntu下，栈区的地址值也是增长的？
查找了很多资料发现，大部分提到linux的栈，地址都是向下生长的，不过，也有以下解释：
第一种解释：
栈向低地址扩展(即”向下生长”)，是连续的内存区域；堆向高地址扩展(即”向上生长”)，是不连续的内存区域。
这是由于系统用链表来存储空闲内存地址，自然不连续，而链表从低地址向高地址遍历。
第二种解释：（暂时放到下面，还需要花时间理解分析这一点）
进程地址空间的分布取决于 *** 作系统，栈向什么方向增长取决于 *** 作系统与CPU的组合。
这里说的“栈”是函数调用栈，是以“栈帧”（stack frame）为单位的。
每一次函数调用会在栈上分配一个新的栈帧，在这次函数调用结束时释放其空间。
被调用函数（callee）的栈帧相对调用函数（caller）的栈帧的位置反映了栈的增长方向：如果被调用函数的栈帧比调用函数的在更低的地址，那么栈就是向下增长；反之则是向上增长。
在一个栈帧内，局部变量是如何分布到栈帧里的（所谓栈帧布局，stack frame layout），这完全是编译器的自由。
在简化的32位Linux/x86进程地址空间模型里，（主线程的）栈空间确实比堆空间的地址要高——它已经占据了用户态地址空间的最高可分配的区域，并且向下（向低地址）增长。
用Gustavo Duarte的Anatomy of a Program in Memory里的图来具体说明：
五、总结举两个例子：
虽然传统上Linux上的malloc实现会使用brk()/sbrk()来实现malloc()（这俩构成了上图中“Heap”所示的部分，这也是Linux自身所认为是heap的地方——用pmap看可以看到这里被标记为[heap]），但这并不是必须的——一个malloc()实现完全可以只用或基本上只用mmap()来实现malloc()，此时一般说的“Heap”（malloc-heap）就不一定在上图“Heap”（Linux heap）所示部分，而会在“Memory Mapping Segment”部分散布开来。不同版本的Linux在分配未指定起始地址的mmap()时用的顺序不一样，并不保证某种顺序。而且mmap()分配到的空间是有可能出现在低于主可执行程序映射进来的text Segment所在的位置。
Linux上多线程进程中，“线程”其实是一组共享虚拟地址空间的进程。只有主线程的栈是按照上面图示分布，其它线程的栈的位置其实是“随机”的——它们可以由pthread_create()调用mmap()来分配，也可以由程序自己调用mmap()之后把地址传给pthread_create()。既然是mmap()来的，其它线程的栈出现在Memory Mapping Segment的任意位置都不出奇，与用于实现malloc()用的mmap()空间很可能是交错出现的。
在必要的时候，对别人得到的结论要加以验证，实际情况可能与大多数情况的结论相悖。
通过本实验对程序内存分配有更加详细深入的了解，这块内容也是博大精深。
堆栈的一般结论如下（不能肯定）：
1.堆和栈空间分配：栈 向低地址扩展；堆 向高地址扩展
2.如果依次定义变量，先定义的栈变量的内存地址比后定义的栈变量的内存地址要大；先定义的堆变量的内存地址比后定义的堆变量的内存地址要小。
3.栈 临时变量，退出该作用域就会自动释放；堆 malloc变量，通过free函数释放。
但实际栈的地址增长方向并不一定，针对具体的函数要具体问题具体分析，我还需要深入的理解才能具体明白这一点。
参考
[1] https://blog.csdn.net/qq_44723773/article/details/109318781
[2] https://blog.csdn.net/yingms/article/details/53188974
[3] https://blog.csdn.net/lin_duo/article/details/103019390
[4] https://blog.csdn.net/liwei16611/article/details/88545248
[5] https://blog.csdn.net/ylzmm/article/details/88852155
[6] https://blog.csdn.net/xwmrqqq/article/details/110149859
[7] https://blog.csdn.net/weixin_33796177/article/details/90125379
欢迎分享，转载请注明来源：内存溢出
微信扫一扫
支付宝扫一扫
评论列表（0条）