关于c语言中局部变量，全局变量，栈，堆，等概念的理解及在ubuntu系统和stm32中的验证

最新推荐文章于 2024-07-02 17:44:31 发布

Chen纳尔

最新推荐文章于 2024-07-02 17:44:31 发布

阅读量249

点赞数

文章标签： c语言 ubuntu stm32

本文链接：https://blog.csdn.net/m0_68927084/article/details/133614548

版权

关于c语言中局部变量，全局变量，栈，堆，等概念的理解及在ubuntu系统和stm32中的验证

一.全局变量和局部变量
- 1.全局变量
- 2. 局部变量
二.栈和堆
- 1.栈和堆
- 2.STM32的堆栈
三.Ubuntu，STM32开发板编程，输出信息进行验证
四、总结

一.全局变量和局部变量

1.全局变量

在C语言中，全局变量是在所有函数外部定义的变量。全局变量可以在整个程序中都可用，它可以在程序的任何函数中被访问。全局变量在定义它的文件的所有函数中都是可见的，而在其他文件中则不可见。这是因为C语言使用文件（即编译单元）作为基本的编译单位，而不是整个程序。

2. 局部变量

在C语言中，局部变量是在函数内部定义的变量，只在其所在的函数范围内有效。这意味着只有在本函数内才能使用它们，在其他函数中无法使用这些变量。局部变量在定义它的语句块或复合语句块中有效，离开这个范围，它们就不再存在。

二.栈和堆

1.栈和堆

堆栈（Stack）是一种重要的数据结构，它遵循后进先出（LIFO）的原则。这意味着最后一个进入堆栈的元素总是第一个被取出。在计算机科学中，堆栈被广泛应用于各种场景，包括函数调用、递归、深度优先搜索等。
堆栈的基本操作包括：

压栈（Push）：在堆栈的顶部添加一个元素。

弹栈（Pop）：删除并返回堆栈顶部的元素。如果堆栈为空，则此操作会导致错误或异常。

peek/top ：返回堆栈顶部的元素，但不删除它。如果堆栈为空，则此操作会导致错误或异常。

isEmpty/isStackEmpty：检查堆栈是否为空。

这些操作的时间复杂度通常是O(1)，即它们在恒定时间内完成，无论堆栈的大小如何。

在程序执行中，堆栈在函数调用和返回时发挥重要作用。当函数被调用时，参数和局部变量被压入堆栈，以便在函数返回时恢复这些值。程序的返回地址也存储在堆栈中，以便当函数完成时，程序知道去哪里继续执行。

例如，下面是一个简单的使用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] = "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;
}

上述程序首先定义了一个数组stack作为堆栈，并且初始化一个变量top来跟踪堆栈的顶部。然后定义了两个操作：push（将数据放入堆栈）和pop（从堆栈中取出数据）。在main函数中，程序将数字5、10和15压入堆栈，然后取出并打印顶部元素的值。

2.STM32的堆栈

STM32中的堆栈（Stack）是一个重要的内部数据结构，用于保存函数调用信息，包括参数、局部变量和返回地址。STM32使用堆栈的主要方式是通过使用函数调用约定。在C语言编程中，通常有两种主要的函数调用约定：
__stdcall和__cdecl。

__stdcall是默认的调用约定，主要用于在调用函数时进行参数压栈。在__stdcall约定中，参数从右向左压入堆栈，并且由调用函数清理堆栈。
__cdecl是另一种调用约定，主要用于在调用函数时进行参数压栈。在__cdecl约定中，参数也是从右向左压入堆栈，但是由被调用函数清理堆栈。
需要注意的是，STM32并没有像PC机那样的操作系统来管理堆栈，所以STM32中的堆栈通常只被用于函数调用和返回，而不会用于更复杂的用途，如线程或中断服务程序的执行。如果你需要在STM32上实现更复杂的并发或并行行为，可能需要考虑使用其他方法，如队列、状态机或其他数据结构。

三.Ubuntu，STM32开发板编程，输出信息进行验证

在ubuntu中运行以下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：%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;
}

在这里插入图片描述我们可以看到，ubuntu在栈和堆的地址都从上到下增长的

接下来我们在keil中运行以下程序

#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)
 {		

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

编译并烧录，我们使用野火调试助手观察到串口返回的信息
在这里插入图片描述可以看到stm32的栈区的地址值是从上到下减小的，堆区则是从上到下增长的。

四、总结

主要是对C程序的内存分配有进一步的认识，知道一个C程序内存应该包括哪些部分。其中，主要是程序段、数据段、堆栈三个部分。不同系统下面，区域内的地址值变化是不相同。总的来说，是对内存的分配有了比较新的认识。

Chen纳尔

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
1
评论
关于c语言中局部变量，全局变量，栈，堆，等概念的理解及在ubuntu系统和stm32中的验证

主要是对C程序的内存分配有进一步的认识，知道一个C程序内存应该包括哪些部分。其中，主要是程序段、数据段、堆栈三个部分。不同系统下面，区域内的地址值变化是不相同。总的来说，是对内存的分配有了比较新的认识。
复制链接

扫一扫