gcc动态库和静态库的运用以及Ubuntu、stm32下的程序内存分配问题

（一）gcc有关介绍

1.gcc简述

gcc是以GPL许可证所发行的自由软件，也是GNU计划的关键部分。gcc的初衷是为GNU操作系统专门编写一款编译器，现已被大多数类Unix操作系统（如Linux、BSD、MacOS X等）采纳为标准的编译器，甚至在微软的Windows上也可以使用gcc。gcc支持多种计算机体系结构芯片，如x86、ARM、MIPS等，并已被移植到其他多种硬件平台。
gcc原名为GNU C语言编译器（GNU C Compiler）、只能处理C语言。但其很快扩展，变得可处理C++，后来又扩展为能够支持更多编程语言，如Fortran、Pascal、Objective -C、Java、Ada、Go以及各类处理器架构上的汇编语言等，所以改名GNU编译器套件（GNU Compiler Collection）。

2.gcc运行原理

利用gcc命令将C语言文件转化为可执行文件需要执行四个步骤，分别是预处理（Preprocessing）、编译（Compilation）、汇编（Assembly）和链接（Linking）。

1.预处理是对源代码的头文件以及预编译语句（如宏定义的define）进行编译。生成的文件后缀名为.i，命令如下 。

打开hello.i文件

我们可以看到主函数以上的头文件已经进行了编译。

2.编译是针对汇编语言的步骤，检查代码以及将其翻译成汇编语言，生成的文件后缀名为.s，命令如下。

打开hello.s文件

可以看到源代码已经转化为了汇编语言。

3.汇编的作用是生成目标文件，文件的后缀名为.o，命令如下

hello.o文件打开我们会看见一堆乱码，是因为汇编产生的是一个二进制文件，但是它是不可以执行的，所以就需要最后一步。

4.链接是将目标文件转化为可执行文件，命令如下

5.最后就可以执行文件了

（二）利用gcc生成静态库和动态库

1.编写函数

编写主函数

编写sub1.c

编写sub1.h

编写sub2.c

编写sub2.h

2.生成静态库

首先生成.o文件

下一步运用ar工具生成静态库，静态库文件名的命名规范是以 lib 为前缀，紧接着跟静态库名，扩展名为.a

运用生成的静态库并且和主函数链接

3.生成动态库

生成.o文件（此处生成.o 文件必须添加"-fpic"(小模式，代码少)，否则在生成.so文件时会出错

动态库文件名命名规范和静态库文件名命名规范类似，也是在动态库名增加前缀 lib，但其
文件扩展名为.so

然后我们使用动态库，生成可执行文件，执行后发现出现了错误

使用ldd命令，查看链接状况，可以看到是找不到.so文件

这是由于 linux 自身系统设定的相应的设置的原因，即其只在/lib 和 /usr/lib 下搜索对应
的.so 文件，故需将对应 so 文件拷贝到对应路径

拷贝完成后在运行就能运行成功了

3.动态库和静态库的比较

静态库特点如下：
1.静态库对函数库的链接是放在编译时期完成的。
2.程序在运行时与函数库再无瓜葛，移植方便。
3.浪费空间和资源，因为所有相关的目标文件与牵涉到的函数库被链接合成一个可执行文件
动态库特点如下：
1.动态库把对一些库函数的链接载入推迟到程序运行的时期。
2.可以实现进程之间的资源共享。（因此动态库也称为共享库）
3.将一些程序升级变得简单。
4.甚至可以真正做到链接载入完全由程序员在程序代码中控制（显示调用）。
我们查看生成的执行文件比较一下
使用静态库生成的文件

再查看动态库生成的文件

可以看到动态库生成文件的大小要比静态库小，就可以得出下面的结论
1.静态库在程序编译时会被连接到目标代码中，程序运行时将不再需要该静态库，因此体积较大。
2.动态库在程序编译时并不会被连接到目标代码中，而是在程序运行是才被载入，因此在程序运行时还需要动态库存在，因此代码体积较小。

（三）Ubuntu、stm32下的程序内存分配

1.全局变量和局部变量

全局变量
在所有函数外部定义的变量称为全局变量（Global Variable），它的作用域默认是整个程序，也就是所有的源文件。
局部变量
定义在函数内部的变量称为局部变量（Local Variable），它的作用域仅限于函数内部， 离开该函数的内部就是无效的，再使用就会报错。

2.堆和栈

堆
堆(Heap)是计算机科学中一类特殊的数据结构的统称。堆通常是一个可以被看做一棵完全二叉树的数组对象。
栈
栈（stack）又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。

3.在Ubuntu中实践

代码如下

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

可以看到Ubuntu在栈区和堆区的地址值都是从上到下增长的。

4.在Keil中实践（参考【嵌入式18】Ubuntu、stm32下的程序内存分配问题（堆栈、局部全局变量等））

代码如下

#include "led.h"
#include "delay.h"
#include "key.h"
#include "sys.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)
 {		
 	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：%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的栈区的地址值是从上到下减小的，堆区则是从上到下增长的。