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

1.全局变量和局部变量

1.1 全局变量

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

1.2 局部变量

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

2.栈和堆

2.1 栈和堆

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

堆栈的基本操作包括：

1. 压栈（Push）：在堆栈的顶部添加一个元素。
2. 弹栈（Pop）：删除并返回堆栈顶部的元素。如果堆栈为空，则此操作会导致错误或异常。
3. peek/top ：返回堆栈顶部的元素，但不删除它。如果堆栈为空，则此操作会导致错误或异常。
4. isEmpty/isStackEmpty：检查堆栈是否为空。

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

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

例如，下面是一个简单的使用C语言实现的堆栈的例子：

#include <stdio.h>
#define MAX_STACK_SIZE 100

int stack[MAX_STACK_SIZE]; //定义一个数组作为堆栈
int top = -1; //初始化顶为-1

void push(int data) {
    if(top>=MAX_STACK_SIZE-1) {
        printf("Stack is full. Can't push %d\n", data);
    } else {
        stack[++top] = data;
    }
}

int pop() {
    if(top==-1) {
        printf("Stack is empty\n");
        return -1; // or an error code
    } else {
        return stack[top--];
    }
}

int main() {
    push(5);
    push(10);
    push(15);
    printf("Top element is %d\n", pop()); 
    return 0;
}

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

2.2stm32的堆栈

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

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

3.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] = "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;
}

使用nano编辑器编辑程c文件，再使用gcc进行编译，执行编译之后的可执行文件，得到以下结果

我们可以看到，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的栈区的地址值是从上到下减小的，堆区则是从上到下增长的。