基于ubuntu和stm32的C程序的内存分配问题

阅读：评论：0

文章目录

（一）C程序的内存分配
（二）Ubuntu和STM32下对C程序输出信息进行验证
（三）stm32开发板上验证
（四）stm32数据的存储位置
（五）总结心得
（六）参考链接

（一）C程序的内存分配

1、栈区（stack）
由编译器自动分配释放，存放函数的参数值，局部变量的值等。其操作方式类似于数据结构中的栈。
2、堆区（heap）
一般由程序员分配释放，若程序员不释放，程序结束时可能由OS回收。它与数据结构中的堆不同，分配方式类似于链表。
3、全局区（静态区）（static）
全局变量和静态变量的存储是放在一块的，初始化的全局变量和静态变量在一块区域，未初始化的全局变量、未初始化的静态变量在相邻的另一块区域。当程序结束后，变量由系统释放。
4、文字常量区
存放常量字符串。当程序结束后，常量字符串由系统释放。
5、程序代码区
存放函数体的二进制代码。

（二）Ubuntu和STM32下对C程序输出信息进行验证

在虚拟机中打开Ubuntu，然后自定义路径，在终端中输入如下命令：
gedit test.c
该命令为新建一个test.c文件

#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：%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;
}

然后使用命令：
gcc test.c进行编译

输入ls可以看到有一个绿色的a.out可执行文件。

输入./a.out命令进行执行

如图可以看到栈区的变量地址和堆区的变量地址。
可以看到栈区的地址和堆区的地址就是逐渐变大。

（三）stm32开发板上验证

这里我使用的是之前的keil工程代码
参考上一篇.
修改代码
ustart.c:

#include "usart.h"//使UASRT串口可用printf函数发送
//在usart.h文件里可更换使用printf函数的串口号	  
#if 1
#pragma import(__use_no_semihosting)             
//标准库需要的支持函数                 
struct __FILE {int handle; 
}; 
FILE __stdout;       
//定义_sys_exit()以避免使用半主机模式    
void _sys_exit(int x){ x = x; 
} 
//重定义fputc函数 
int fputc(int ch, FILE *f){      while((USART_n->SR&0X40)==0);//循环发送,直到发送完毕   USART_n->DR = (u8) ch;      return ch;
}
#endif void _ttywrch(int ch)
{
ch = ch;
}/*
USART1串口相关程序
*/#if EN_USART1   //USART1使用与屏蔽选择
u8 USART1_RX_BUF[USART1_REC_LEN];     //接收缓冲,最大USART_REC_LEN个字节.
//接收状态
//bit15，	接收完成标志
//bit14，	接收到0x0d
//bit13~0，	接收到的有效字节数目
u16 USART1_RX_STA=0;       //接收状态标记	  /*
USART1专用的printf函数
当同时开启2个以上串口时，printf函数只能用于其中之一，其他串口要自创独立的printf函数
调用方法：USART1_printf("123"); //向USART2发送字符123
*/
//void USART1_printf (char *fmt, ...){ 
//	char buffer[USART1_REC_LEN+1];  // 数据长度
//	u8 i = 0;	
//	va_list arg_ptr;
//	va_start(arg_ptr, fmt);  
//	vsnprintf(buffer, USART1_REC_LEN+1, fmt, arg_ptr);
//	while ((i < USART1_REC_LEN) && (i < strlen(buffer))){
//        USART_SendData(USART1, (u8) buffer[i++]);
//        while (USART_GetFlagStatus(USART1, USART_FLAG_TC) == RESET); 
//	}
//	va_end(arg_ptr);
//}void USART1_Init(u32 bound){ //串口1初始化并启动//GPIO端口设置GPIO_InitTypeDef GPIO_InitStructure;USART_InitTypeDef USART_InitStructure;NVIC_InitTypeDef NVIC_InitStructure;	 RCC_APB2PeriphClockCmd(RCC_APB2Periph_USART1|RCC_APB2Periph_GPIOA, ENABLE);	//使能USART1，GPIOA时钟//USART1_TX   PA.9GPIO_InitStructure.GPIO_Pin = GPIO_Pin_9; //PA.9GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;	//复用推挽输出GPIO_Init(GPIOA, &GPIO_InitStructure);  //USART1_RX	  PA.10GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入GPIO_Init(GPIOA, &GPIO_InitStructure); //Usart1 NVIC 配置NVIC_InitStructure.NVIC_IRQChannel = USART1_IRQn;NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=0 ;//抢占优先级3NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;		//子优先级3NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;			//IRQ通道使能NVIC_Init(&NVIC_InitStructure);	//根据指定的参数初始化VIC寄存器 //USART 初始化设置USART_InitStructure.USART_BaudRate = bound;//一般设置为9600;USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式USART_InitStructure.USART_StopBits = USART_StopBits_1;//一个停止位USART_InitStructure.USART_Parity = USART_Parity_No;//无奇偶校验位USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;	//收发模式USART_Init(USART1, &USART_InitStructure); //初始化串口USART_ITConfig(USART1, USART_IT_RXNE, ENABLE);//开启ENABLE/关闭DISABLE中断接收到数据时中断 读寄存器DR清零，也可软件手动清零USART_Cmd(USART1, ENABLE);                    //使能串口 
}void USART1_IRQHandler(void){ //串口1中断服务程序（固定的函数名不能修改）	u8 Res;//以下是字符串接收到USART1_RX_BUF[]的程序，(USART1_RX_STA&0x3FFF)是数据的长度（不包括回车）//当(USART1_RX_STA&0xC000)为真时表示数据接收完成，即超级终端里按下回车键。//在主函数里写判断if(USART1_RX_STA&0xC000)，然后读USART1_RX_BUF[]数组，读到0x0d 0x0a即是结束。//注意在主函数处理完串口数据后，要将USART1_RX_STA清0if(USART_GetITStatus(USART1, USART_IT_RXNE) != RESET){  //接收中断(接收到的数据必须是0x0d 0x0a结尾)		Res =USART_ReceiveData(USART1);//(USART1->DR);	//读取接收到的数据printf("%c",Res); //把收到的数据以 a符号变量 发送回电脑		if((USART1_RX_STA&0x8000)==0){//接收未完成			if(USART1_RX_STA&0x4000){//接收到了0x0d				if(Res!=0x0a)USART1_RX_STA=0;//接收错误,重新开始else USART1_RX_STA|=0x8000;	//接收完成了 }else{ //还没收到0X0D					if(Res==0x0d)USART1_RX_STA|=0x4000;else{USART1_RX_BUF[USART1_RX_STA&0X3FFF]=Res ; //将收到的数据放入数组USART1_RX_STA++;	//数据长度计数加1if(USART1_RX_STA>(USART1_REC_LEN-1))USART1_RX_STA=0;//接收数据错误,重新开始接收	  }		 }}   		 } 
} 
#endif	/*
USART2串口相关程序
*/
#if EN_USART2   //USART2使用与屏蔽选择
u8 USART2_RX_BUF[USART2_REC_LEN];     //接收缓冲,最大USART_REC_LEN个字节.
//接收状态
//bit15，	接收完成标志
//bit14，	接收到0x0d
//bit13~0，	接收到的有效字节数目
u16 USART2_RX_STA=0;       //接收状态标记	  /*
USART2专用的printf函数
当同时开启2个以上串口时，printf函数只能用于其中之一，其他串口要自创独立的printf函数
调用方法：USART2_printf("123"); //向USART2发送字符123
*/
void USART2_printf (char *fmt, ...){ char buffer[USART2_REC_LEN+1];  // 数据长度u8 i = 0;	va_list arg_ptr;va_start(arg_ptr, fmt);  vsnprintf(buffer, USART2_REC_LEN+1, fmt, arg_ptr);while ((i < USART2_REC_LEN) && (i < strlen(buffer))){USART_SendData(USART2, (u8) buffer[i++]);while (USART_GetFlagStatus(USART2, USART_FLAG_TC) == RESET); }va_end(arg_ptr);
}void USART2_Init(u32 bound){ //串口1初始化并启动//GPIO端口设置GPIO_InitTypeDef GPIO_InitStructure;USART_InitTypeDef USART_InitStructure;NVIC_InitTypeDef NVIC_InitStructure;RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOA , ENABLE); //使能UART2所在GPIOA的时钟RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART2, ENABLE); //使能串口的RCC时钟GPIO_InitStructure.GPIO_Pin = GPIO_Pin_3; //设置USART2的RX接口是PA3GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//浮空输入GPIO_Init(GPIOA, &GPIO_InitStructure); GPIO_InitStructure.GPIO_Pin = GPIO_Pin_2; //设置USART2的TX接口是PA2GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;GPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;	//复用推挽输出GPIO_Init(GPIOA, &GPIO_InitStructure);  //USART2 初始化设置USART_InitStructure.USART_BaudRate = bound;//一般设置为9600;USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式USART_InitStructure.USART_StopBits = USART_StopBits_1;//一个停止位USART_InitStructure.USART_Parity = USART_Parity_No;//无奇偶校验位USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;	//收发模式USART_Init(USART2, &USART_InitStructure); //初始化串口USART_ITConfig(USART2, USART_IT_RXNE, ENABLE);//开启ENABLE/关闭DISABLE中断USART_Cmd(USART2, ENABLE);                    //使能串口 //Usart2 NVIC 配置NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);NVIC_InitStructure.NVIC_IRQChannel = USART2_IRQn;NVIC_InitStructure.NVIC_IRQChannelPreemptionPriority=3 ;//抢占优先级3NVIC_InitStructure.NVIC_IRQChannelSubPriority = 3;		//优先级3NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;			//IRQ通道使能NVIC_Init(&NVIC_InitStructure);	//根据指定的参数初始化VIC寄存器 
}void USART2_IRQHandler(void){ //串口2中断服务程序（固定的函数名不能修改）	u8 Res;//以下是字符串接收到USART2_RX_BUF[]的程序，(USART2_RX_STA&0x3FFF)是数据的长度（不包括回车）//当(USART2_RX_STA&0xC000)为真时表示数据接收完成，即超级终端里按下回车键。//在主函数里写判断if(USART2_RX_STA&0xC000)，然后读USART2_RX_BUF[]数组，读到0x0d 0x0a即是结束。//注意在主函数处理完串口数据后，要将USART2_RX_STA清0if(USART_GetITStatus(USART2, USART_IT_RXNE) != RESET){  //接收中断(接收到的数据必须是0x0d 0x0a结尾)		Res =USART_ReceiveData(USART2);//(USART1->DR);	//读取接收到的数据printf("%c",Res); //把收到的数据以 a符号变量 发送回电脑		if((USART2_RX_STA&0x8000)==0){//接收未完成			if(USART2_RX_STA&0x4000){//接收到了0x0d				if(Res!=0x0a)USART2_RX_STA=0;//接收错误,重新开始else USART2_RX_STA|=0x8000;	//接收完成了 }else{ //还没收到0X0D					if(Res==0x0d)USART2_RX_STA|=0x4000;else{USART2_RX_BUF[USART2_RX_STA&0X3FFF]=Res ; //将收到的数据放入数组USART2_RX_STA++;	//数据长度计数加1if(USART2_RX_STA>(USART2_REC_LEN-1))USART2_RX_STA=0;//接收数据错误,重新开始接收	  }		 }}   		 } 
} 
#endif	#if EN_USART3   //如果使能了接收
u8 USART3_RX_BUF[USART3_REC_LEN];     //接收缓冲,最大USART_REC_LEN个字节.
//接收状态
//bit15，	接收完成标志
//bit14，	接收到0x0d
//bit13~0，	接收到的有效字节数目
u16 USART3_RX_STA=0;       //接收状态标记	  /*
USART3专用的printf函数
当同时开启2个以上串口时，printf函数只能用于其中之一，其他串口要自创独立的printf函数
调用方法：USART3_printf("123"); //向USART3发送字符123
*/
void USART3_printf (char *fmt, ...){ char buffer[USART3_REC_LEN+1];  // 数据长度u8 i = 0;	va_list arg_ptr;va_start(arg_ptr, fmt);  vsnprintf(buffer, USART3_REC_LEN+1, fmt, arg_ptr);while ((i < USART3_REC_LEN) && (i < strlen(buffer))){USART_SendData(USART3, (u8) buffer[i++]);while (USART_GetFlagStatus(USART3, USART_FLAG_TC) == RESET); }va_end(arg_ptr);
}void USART3_Init(u32 BaudRate){ //USART3初始化并启动GPIO_InitTypeDef GPIO_InitStructure;USART_InitTypeDef USART_InitStructure;NVIC_InitTypeDef NVIC_InitStructure; RCC_APB2PeriphClockCmd(RCC_APB2Periph_GPIOB , ENABLE); //使能UART3所在GPIOB的时钟RCC_APB1PeriphClockCmd(RCC_APB1Periph_USART3, ENABLE); //使能串口的RCC时钟//串口使用的GPIO口配置GPIO_InitStructure.GPIO_Pin = GPIO_Pin_11;//设置USART3的RX接口是PB11GPIO_InitStructure.GPIO_Mode = GPIO_Mode_IN_FLOATING;//接口模式 浮空输入GPIO_Init(GPIOB, &GPIO_InitStructure);GPIO_InitStructure.GPIO_Pin = GPIO_Pin_10;//设置USART3的TX接口是PB10GPIO_InitStructure.GPIO_Speed = GPIO_Speed_50MHz;//输出速度50MHzGPIO_InitStructure.GPIO_Mode = GPIO_Mode_AF_PP;//接口模式 复用推挽输出GPIO_Init(GPIOB, &GPIO_InitStructure);//配置串口USART_InitStructure.USART_BaudRate = BaudRate;USART_InitStructure.USART_WordLength = USART_WordLength_8b;//字长为8位数据格式USART_InitStructure.USART_StopBits = USART_StopBits_1;//一个停止位USART_InitStructure.USART_Parity = USART_Parity_No;//无奇偶校验位USART_InitStructure.USART_HardwareFlowControl = USART_HardwareFlowControl_None;//无硬件数据流控制USART_InitStructure.USART_Mode = USART_Mode_Rx | USART_Mode_Tx;	//收发模式USART_Init(USART3, &USART_InitStructure);//配置串口3USART_ITConfig(USART3, USART_IT_RXNE, ENABLE);//使能串口接收中断  //USART_ITConfig(USART3, USART_IT_TXE, ENABLE);//串口发送中断在发送数据时开启USART_Cmd(USART3, ENABLE);//使能串口3//串口中断配置NVIC_PriorityGroupConfig(NVIC_PriorityGroup_0);NVIC_InitStructure.NVIC_IRQChannel = USART3_IRQn;//允许USART3中断NVIC_InitStructure.NVIC_IRQChannelSubPriority = 0;//中断等级NVIC_InitStructure.NVIC_IRQChannelCmd = ENABLE;NVIC_Init(&NVIC_InitStructure);
}//串口3中断服务程序（固定的函数名不能修改）
//调用方法：if(USART3_RX_STA&0xC000){ 加入数据处理程序 }//标志位是0xC000表示收到数据串完成。
void USART3_IRQHandler(void){ 	u8 Res;if(USART_GetITStatus(USART3, USART_IT_RXNE) != RESET){  //接收中断Res =USART_ReceiveData(USART3);//读取接收到的数据if(Res=='S'){//判断数据是否是STOP（省略读取S）			USART3_RX_STA=1;//如果是STOP则标志位为1	  }else if(Res=='K'){//判断数据是否是OK（省略读取K）			USART3_RX_STA=2;//如果是OK则标志位为2	  }   		 }
} 
#endif	/********************************************************************************************** 杜洋工作室 www.DoYoung* 洋桃电子 www.DoYoung/YT 
*********************************************************************************************//*
a符号的作用：%d 十进制有符号整数
%u 十进制无符号整数
%f 浮点数
%s 字符串
%c 单个字符
%p 指针的值
%e 指数形式的浮点数
%x, %X 无符号以十六进制表示的整数
%o 无符号以八进制表示的整数
%g 自动选择合适的表示法
%p 输出地址符*/

usart.h:

#ifndef __USART_H
#define __USART_H
//#include <stdarg.h>
//#include <stdlib.h>
#include <string.h>
#include "stdio.h"	
#include "sys.h" #define USART_n		USART1  //定义使用printf函数的串口，其他串口要使用USART_printf专用函数发送#define USART1_REC_LEN  			200  	//定义USART1最大接收字节数
#define USART2_REC_LEN  			200  	//定义USART2最大接收字节数
#define USART3_REC_LEN  			200  	//定义USART3最大接收字节数//不使用某个串口时要禁止此串口，以减少编译量
#define EN_USART1 			1		//使能（1）/禁止（0）串口1
#define EN_USART2 			0		//使能（1）/禁止（0）串口2
#define EN_USART3 			0		//使能（1）/禁止（0）串口3extern u8  USART1_RX_BUF[USART1_REC_LEN]; //接收缓冲,最大USART_REC_LEN个字节.末字节为换行符 
extern u8  USART2_RX_BUF[USART2_REC_LEN]; //接收缓冲,最大USART_REC_LEN个字节.末字节为换行符
extern u8  USART3_RX_BUF[USART3_REC_LEN]; //接收缓冲,最大USART_REC_LEN个字节.末字节为换行符extern u16 USART1_RX_STA;         		//接收状态标记	
extern u16 USART2_RX_STA;         		//接收状态标记	
extern u16 USART3_RX_STA;         		//接收状态标记	//函数声明
void USART1_Init(u32 bound);//串口1初始化并启动
void USART2_Init(u32 bound);//串口2初始化并启动
void USART3_Init(u32 bound);//串口3初始化并启动
void USART1_printf(char* fmt,...); //串口1的专用printf函数
void USART2_printf(char* fmt,...); //串口2的专用printf函数
void USART3_printf(char* fmt,...); //串口3的专用printf函数#endif

main.c:

#include "stm32f10x.h" //STM32头文件
#include "sys.h"
#include "delay.h"#include "usart.h"
#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 (void){//主程序u8 a=7,b=8;//初始化程序RCC_Configuration(); //时钟设置USART1_Init(115200); //串口初始化（参数是波特率）//主循环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] = "cleveryoga";//定义常量字符串char *var1 = "1234567890";char *var2 = "abcdefghij";//动态分配int *p1=malloc(4);int *p2=malloc(4);//释放free(p1);free(p2);printf("栈区-变量地址nr");printf("                a：%pnr", &a);printf("                init_local_d：%pnr", &init_local_d);printf("                p：%pnr", &p);printf("              str：%pnr", str);printf("n堆区-动态申请地址nr");printf("                   %pnr", p1);printf("                   %pnr", p2);printf("n全局区-全局变量和静态变量nr");printf("n.bss段n");printf("全局外部无初值 uninit_global_a：%pnr", &uninit_global_a);printf("静态外部无初值 uninits_global_b：%pnr", &uninits_global_b);printf("静态内部无初值 uninits_local_c：%pnr", &uninits_local_c);printf("n.data段nr");printf("全局外部有初值 init_global_a：%pnr", &init_global_a);printf("静态外部有初值 inits_global_b：%pnr", &inits_global_b);printf("静态内部有初值 inits_local_c：%pnr", &inits_local_c);printf("n文字常量区nr");printf("文字常量地址     ：%pnr",var1);printf("文字常量地址     ：%pnr",var2);printf("n代码区nr");printf("程序区地址       ：%pnr",&main);printf("函数地址         ：%pnr",&output);delay_ms(1000); //延时}
}

编译生成.hex
烧录

在串口助手打开得到如下结果

上图结果可以看出栈区变量地址和堆区变量地址是逐渐变小的，与Ubuntu中看的的结果相反。
这是因为STM32中的存储位置不同。