嵌入式Ubuntu、stm32下的程序内存分配问题（堆栈、局部全局变量等）

不会困的小易

已于 2024-05-14 14:39:37 修改

阅读量107

点赞数

文章标签： ubuntu stm32 linux c++

于 2023-10-06 17:52:37 首次发布

本文链接：https://blog.csdn.net/m0_64999194/article/details/133615170

版权

Ubuntu、stm32下的程序内存分配问题(堆栈、全局、局部等变量）

一.全局变量与局部变量
二.堆与栈
- 栈
- 堆
三.Ubuntu（x86）系统和STM32(Keil)中进行编程、验证
- 1.Ubuntu（x86）系统
- 2.STM32(Keil)系统
总结

一.全局变量与局部变量

全局变量

在整个程序中都可以访问的变量，其作用域是全局的，通常在程序的顶层声明或在函数外部声明。

局部变量

只能在其声明所在的特定代码块（通常是函数内部）中访问的变量，其作用域被限制在该代码块内。

区别

全局变量	局部变量
在方法外部，直接写在类中	在方法内部
如果没有赋值，则有默认值，规则同数组	没有默认值，要使用必须手动赋值
位于堆内存	位于栈内存

二.堆与栈

栈

栈是一种线性数据结构，通常采用先进先出（FIFO）的方式管理数据。
用于存储函数的局部变量和函数调用的执行上下文。
内存分配和释放自动发生，由编译器/解释器管理。
栈上的数据通常拥有较小的生命周期，当函数执行完毕时，栈上的局部变量自动被销毁。
栈的内存管理效率高，但大小有限，通常较小。

堆

堆是一种非线性数据结构，用于存储动态分配的数据，例如对象、数组等。
内存分配和释放由程序员手动管理，通常需要显式分配和释放内存。
堆上的数据可以拥有长生命周期，直到显式释放为止，因此用于存储动态数据。
堆的内存管理效率较低，因为需要程序员负责管理内存，可能出现内存泄漏或释放错误的问题。

在一个STM32程序代码中，从内存高地址到内存低地址，依次分布着栈区、堆区、全局区（静态区）、常量去、代码区，其中全局区中高地址分布着.bss段，低地址分布着.data段。
通过下面的思维导图对这部分内容进行详细的介绍：
在这里插入图片描述

三.Ubuntu（x86）系统和STM32(Keil)中进行编程、验证

1.Ubuntu（x86）系统

1.在终端输入以下指令，创建一个文件test1，存放需要用到的代码

#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] = "yaoyao";//栈
    //定义常量字符串
    char *var1 = "1234567890";
    char *var2 = "abcdefghij";
    //动态分配——堆区
    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;
}

2.输入指令 gcc test.c -o test1编译生成可执行文件，使用./test运行文件，观察输出的结果，输出的结果见下图
在这里插入图片描述
可以看到结果和之前的理论相同，数据先进后出，系统先为先进去的数据分配地址。

2.STM32(Keil)系统

1.配置keil的内存
在这里插入图片描述
2.修改主函数代码

/* USER CODE BEGIN Header */
/**
  ******************************************************************************
  * @file           : main.c
  * @brief          : Main program body
  ******************************************************************************
  * @attention
  *
  * <h2><center>&copy; Copyright (c) 2021 STMicroelectronics.
  * All rights reserved.</center></h2>
  *
  * This software component is licensed by ST under BSD 3-Clause license,
  * the "License"; You may not use this file except in compliance with the
  * License. You may obtain a copy of the License at:
  *                        opensource.org/licenses/BSD-3-Clause
  *
  ******************************************************************************
  */
/* USER CODE END Header */
/* Includes ------------------------------------------------------------------*/
#include "main.h"
#include "usart.h"
#include "gpio.h"
#include <stdio.h>
#include <stdlib.h>

/* Private includes ----------------------------------------------------------*/
/* USER CODE BEGIN Includes */
#include<stdio.h>
/* USER CODE END Includes */

/* Private typedef -----------------------------------------------------------*/
/* USER CODE BEGIN PTD */

/* USER CODE END PTD */

/* Private define ------------------------------------------------------------*/
/* USER CODE BEGIN PD */
/* USER CODE END PD */

/* Private macro -------------------------------------------------------------*/
/* USER CODE BEGIN PM */

/* USER CODE END PM */

/* Private variables ---------------------------------------------------------*/

/* USER CODE BEGIN PV */

/* USER CODE END PV */

/* Private function prototypes -----------------------------------------------*/
void SystemClock_Config(void);
/* USER CODE BEGIN PFP */

/* USER CODE END PFP */

/* Private user code ---------------------------------------------------------*/
/* USER CODE BEGIN 0 */

/* USER CODE END 0 */

/**
  * @brief  The application entry point.
  * @retval int
  */
  
  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)
{
  /* USER CODE BEGIN 1 */

  /* USER CODE END 1 */

  /* MCU Configuration--------------------------------------------------------*/

  /* Reset of all peripherals, Initializes the Flash interface and the Systick. */
  HAL_Init();

  /* USER CODE BEGIN Init */

  /* USER CODE END Init */

  /* Configure the system clock */
  SystemClock_Config();

  /* USER CODE BEGIN SysInit */

  /* USER CODE END SysInit */

  /* Initialize all configured peripherals */
  MX_GPIO_Init();
  MX_USART1_Init();
  /* USER CODE BEGIN 2 */

  /* USER CODE END 2 */

  /* Infinite loop */
  /* USER CODE BEGIN WHILE */
  while (1)
  {
    /* USER CODE END WHILE */

    /* USER CODE BEGIN 3 */
//HAL_Delay(1000);
//HAL_GPIO_WritePin(GPIOC, GPIO_PIN_13, GPIO_PIN_RESET);
//HAL_Delay(1000);
//HAL_GPIO_WritePin(GPIOC,GPIO_PIN_13,GPIO_PIN_SET);
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;

		}
  /* USER CODE END 3 */
}

/**
  * @brief System Clock Configuration
  * @retval None
  */
void SystemClock_Config(void)
{
  RCC_OscInitTypeDef RCC_OscInitStruct = {0};
  RCC_ClkInitTypeDef RCC_ClkInitStruct = {0};

  /** Initializes the RCC Oscillators according to the specified parameters
  * in the RCC_OscInitTypeDef structure.
  */
  RCC_OscInitStruct.OscillatorType = RCC_OSCILLATORTYPE_HSE;
  RCC_OscInitStruct.HSEState = RCC_HSE_ON;
  RCC_OscInitStruct.HSEPredivValue = RCC_HSE_PREDIV_DIV1;
  RCC_OscInitStruct.HSIState = RCC_HSI_ON;
  RCC_OscInitStruct.PLL.PLLState = RCC_PLL_ON;
  RCC_OscInitStruct.PLL.PLLSource = RCC_PLLSOURCE_HSE;
  RCC_OscInitStruct.PLL.PLLMUL = RCC_PLL_MUL9;
  if (HAL_RCC_OscConfig(&RCC_OscInitStruct) != HAL_OK)
  {
    Error_Handler();
  }
  /** Initializes the CPU, AHB and APB buses clocks
  */
  RCC_ClkInitStruct.ClockType = RCC_CLOCKTYPE_HCLK|RCC_CLOCKTYPE_SYSCLK
                              |RCC_CLOCKTYPE_PCLK1|RCC_CLOCKTYPE_PCLK2;
  RCC_ClkInitStruct.SYSCLKSource = RCC_SYSCLKSOURCE_PLLCLK;
  RCC_ClkInitStruct.AHBCLKDivider = RCC_SYSCLK_DIV1;
  RCC_ClkInitStruct.APB1CLKDivider = RCC_HCLK_DIV2;
  RCC_ClkInitStruct.APB2CLKDivider = RCC_HCLK_DIV1;

  if (HAL_RCC_ClockConfig(&RCC_ClkInitStruct, FLASH_LATENCY_2) != HAL_OK)
  {
    Error_Handler();
  }
}

/* USER CODE BEGIN 4 */

/* USER CODE END 4 */

/**
  * @brief  This function is executed in case of error occurrence.
  * @retval None
  */
void Error_Handler(void)
{
  /* USER CODE BEGIN Error_Handler_Debug */
  /* User can add his own implementation to report the HAL error return state */

  /* USER CODE END Error_Handler_Debug */
}

#ifdef  USE_FULL_ASSERT
/**
  * @brief  Reports the name of the source file and the source line number
  *         where the assert_param error has occurred.
  * @param  file: pointer to the source file name
  * @param  line: assert_param error line source number
  * @retval None
  */
void assert_failed(uint8_t *file, uint32_t line)
{
  /* USER CODE BEGIN 6 */
  /* User can add his own implementation to report the file name and line number,
     tex: printf("Wrong parameters value: file %s on line %d\r\n", file, line) */
  /* USER CODE END 6 */
}
#endif /* USE_FULL_ASSERT */

/************************ (C) COPYRIGHT STMicroelectronics *****END OF FILE****/

3.使用串口调试助手，可以观察到结果
在这里插入图片描述
stm32的栈区的地址值是从下到上到增长的，堆区则是从上到下增长的，与Ubantu中是有点不同的，说明两个系统堆栈分配地址的方式可能有不同

总结

通过本实验对程序内存分配有更加详细深入的了解，熟悉了Linux基本命令和文件系统结构。学习了如何分配和管理堆内存和栈内存。在嵌入式系统中，内存管理非常重要，要注意避免内存泄漏和栈溢出问题。学习如何分配和管理堆内存和栈内存。在嵌入式系统中，内存管理非常重要，要注意避免内存泄漏和栈溢出问题。
参考：链接link

不会困的小易

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
嵌入式Ubuntu、stm32下的程序内存分配问题（堆栈、局部全局变量等）

通过本实验对程序内存分配有更加详细深入的了解，熟悉了Linux基本命令和文件系统结构。学习了如何分配和管理堆内存和栈内存。在嵌入式系统中，内存管理非常重要，要注意避免内存泄漏和栈溢出问题。学习如何分配和管理堆内存和栈内存。在嵌入式系统中，内存管理非常重要，要注意避免内存泄漏和栈溢出问题。参考：链接link。
复制链接

扫一扫