gcc生成静态库.a和动态库.so

一.用gcc生成静态库和动态库

（1）hello实例库

1.准备所需文件

创建一个test1目录用来存放此次所需文件，并在该目录下创建 hello.h hello.c main.c三个文件

2.将hello.c文件编译成hello.o文件

3.由.o文件创建静态库

4.在程序中使用静态库

a. gcc -o hello main.c -L -lmyhello

b.gcc main.c libmyhello.a -o hello

c. 先生成main.o文件 gcc -c main.c 在生成可执行文件gcc -o hello main.o libmyhell

5由.o文件创建动态文件

# gcc -shared -fPIC -o libmyhello.so hello.o

其中-o不可以少
6.在程序中使用动态库

gcc -o hello main.c -L. -lmyhell

可以看到一切成功，但最后在用./hello时候出错，，原来是找不到动态库文件 libmyhello.so。程序在运行时，
会在/usr/lib 和/lib 等目录中查找需要的动态库文件。若找到，则载入动态库，否则将提示类似上述错误而终止程序运行。我们将文件 libmyhello.so 复制到目录/usr/lib 中，再试试。

.
可以看到又报错了，这时我们可以尝试在终端输入sudo su,输入密码，切换到root用户下，再输入cp libmyhello.so /usr/lib命令，将libmyhello.so复制到/usr/lib目录之下，最后输入./hello执行程序。

成功执行！

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

步骤如下：
gcc编译得到.o文件 gcc -c hello.c
创建静态库 ar -crv libmyhello.a hello.o
创建动态库 gcc -shared -fPIC -o libmyhello.so hello.o
使用库生成可执行文件 gcc -o hello main.c -L. -lmyhello
执行可执行文件 ./hello
先删除添加到/usr/linb目录下的 libmyhello.so文件，以及生成的.o文件



可以看到和我们刚创建动态库并使用时的错误一样，由此可见同时创建静态库和动态库时系统会自动使用动态库，默认去连接/uer/lib等目录下的动态库，那么就得把libmyhello.so的路径添加到目录下

（2）实例使用库

创建a1.c a2.c test.c文件



生成静态库并执行

生成动态库并执行

静态库比动态库小得多

二.编写一个C程序，重温全局常量、全局变量、局部变量、静态变量、堆、栈等概念，在Ubuntu（x86）系统和STM32(Keil)中分别进行编程、验证（STM32 通过串口printf 信息到上位机串口助手) 。

全局变量

全局变量是编程术语中的一种，源自于变量之分。变量分为局部与全局，局部变量又可称之为内部变量。由某对象或某个函数所创建的变量通常都是局部变量，只能被内部引用，而无法被其它对象或函数引用。全局变量既可以是某对象函数创建，也可以是在本程序任何地方创建。全局变量是可以被本程序所有对象或函数引用。

局部变量，

也称内部变量，是指在一个函数内部或复合语句内部定义的变量，局部变量的作用域是定义该变量的函数或定义该变量的复合语句。局部变量的生存期是从函数被调用的时刻算起到函数返回调用处的时刻结束。

堆(Heap)

堆是计算机科学中一类特殊的数据结构的统称。堆通常是一个可以被看做一棵完全二叉树的数组对象

栈（stack）

又名堆栈，它是一种运算受限的线性表。限定仅在表尾进行插入和删除操作的线性表。这一端被称为栈顶，相对地，把另一端称为栈底。向一个栈插入新元素又称作进栈、入栈或压栈，它是把新元素放到栈顶元素的上面，使之成为新的栈顶元素；从一个栈删除元素又称作出栈或退栈，它是把栈顶元素删除掉，使其相邻的元素成为新的栈顶元素。

代码

#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] = "lmy";
    //定义常量字符串
    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;
}
 

ubantu下的演示

stm32的演示

对比

(1)性能
栈：栈存在于RAM中，栈是动态的，它的存储速度是第二快的。
堆：堆位于RAM中，是一个通用的内存池。所有的对象都存储在堆中。

(2)申请方式
栈: 由系统自动分配。 例如，声明在函数中一个局部变量 int b，系统自动在栈中为b开辟空间 。
堆: 需要程序员自己申请，并指明大小，在c中malloc函数如p1 = (char *)malloc(10); 在C++中用new运算符如p2 = (char *)malloc(10);但是注意：p1、p2本身是在栈中的。

(3)申请后系统的响应
栈：只要栈的剩余空间大于所申请空间，系统将为程序提供内存，否则将报异常提示栈溢出。
堆：首先应该知道操作系统有一个记录空闲内存地址的链表，当系统收到程序的申请时，会遍历该链表，寻找第一个空间大于所申请空间的堆结点，然后将该结点从空闲结点链表中删除，并将该结点的空间分配给程序；另外，对于大多数系统，会在这块内存空间中的首地址处记录本次分配的大小，这样代码中的delete语句才能正确的释放本内存空间。另外，由于找到的堆结点的大小不一定正好等于申请的大小，系统会自动的将多余的那部分重新放入空闲链表中。

(4)申请大小的限制
栈：在Windows下，栈是向低地址扩展的数据结构，是一块连续的内存的区域。这句话的意思是栈顶的地址和栈的最大容量是系统预先规定好的，在WINDOWS下，栈的大小是2M（也有的说是1M，总之是一个编译时就确定的常数），如果申请的空间超过栈的剩余空间时，将提示overflow。因此，能从栈获得的空间较小。
堆：堆是向高地址扩展的数据结构，是不连续的内存区域。这是由于系统是用链表来存储的空闲内存地址的，自然是不连续的，而链表的遍历方向是由低地址向高地址。堆的大小受限于计算机系统中有效的虚拟内存。由此可见，堆获得的空间比较灵活，也比较大。

(5)申请效率的比较
栈：由系统自动分配，速度较快。但程序员是无法控制的。
堆：是由new分配的内存，一般速度比较慢，而且容易产生内存碎片，不过用起来最方便.
另外，在WINDOWS下，最好的方式是用VirtualAlloc分配内存，他不是在堆，也不是在栈是直接在进程的地址空间中保留一快内存，虽然用起来最不方便。但是速度快，也最灵活。

(6)堆和栈中的存储内容
栈：在函数调用时，第一个进栈的是主函数中后的下一条指令（函数调用语句的下一条可执行语句）的地址，然后是函数的各个参数，在大多数的C编译器中，参数是由右往左入栈的，然后是函数中的局部变量，注意静态变量是不入栈的。当本次函数调用结束后，局部变量先出栈，然后是参数，最后栈顶指针指向最开始存的地址，也就是主函数中的下一条指令，程序由该点继续运行。
堆：一般是在堆的头部用一个字节存放堆的大小。堆中的具体内容有程序员安排

(7)存取效率的比较
char s1[] = “aaaaaaaaaaaaaaa”;
char *s2 = “bbbbbbbbbbbbbbbbb”;
aaaaaaaaaaa是在运行时刻赋值的； 而bbbbbbbbbbb是在编译时就确定的； 但是，在以后的存取中，在栈上的数组比指针所指向的字符串(例如堆)快。

三.总结

通过对gcc生成动态库和静态库的练习，能够熟练的生成动态库和静态库，在对静态库和动态库的比较下很明显看出动态库占用的内存比静态库多得多，并且知道了同时生成动态库和静态库时，系统默认使用动态库。此外使用静态库时不需要将静态库的路径写道/usr/lib下，而使用动态库时执行文件后会在/usr/lib等路径下寻找对应的动态库，此时需要添加动态库到对应路径。

参考资料：
GCC编译器的常用命令及使用
重温全局变量、局部变量、堆、栈等概念
Ubuntu、stm32下的C程序中堆、栈、全局、局部等变量的分对比分析