Ubuntu­---使用gcc生成静态库.a和动态库.so

一、gcc生成静态库和动态

• 静态库：在程序编译时会被连接到目标代码中，程序运行时将不在需要该静态库。
• 动态库：在程序编译时并不会被连接到目标代码中，而是在程序运行时才被载入，因此在程序运行时还需要动态库存在。

（1）Hello实例库

1、准备所需文件

创建一个text1目录，将hello.c，hello.h和main.c文件保存于此

mkdir test1
cd test1

hello.c代码

#include<stdio.h>
void hello(const char *name)
{
	printf("Hello %s\n",name);
}

hello.h代码

#ifndef HELLO_H
#define HELLO_H
void hello(const char *name);
#endif//HELLO_H

main.c代码

#include"hello.h"
int main()
{
	hello("everyone");
	return 0;
}

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

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

• 使用ar命令创建
• 静态库命名格式：lib前缀 / .a文件拓展名

ar -crv libmyhello.a hello.o

4、在程序中使用静态库

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

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

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

4. 我们删除静态库文件试试公用函数hello是否真的连接到目标文件hello中了
   
   发现程序照常运行，说明公用函数已经连接到目标文件中了

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

• gcc创建
• 动态库命名格式：lib前缀 / .so文件拓展名
  
  其中 -o 必不可少

6、在程序中使用动态库

输入gcc -o hello main.c -L. -lmyhell
接下来 ./hello 时提示“没有那个文件或目录”，因为虽然连接时用的是当前目录的动态库，但是运行时，是到/usr/lib中找库文件的，将文件libmyhello.so复制到目录/usr/lib中就好了。
mv libmyhello.so /usr/lib

这里发现权限不够，输入sudo su进入root模式下再复制刚才的文件，运行之即可。

7、探究静态库与动态库名相同时，gcc会使用哪个库文件

• 先删除除了.c和.h外的所有文件rm -f hello hello.o /usr/lib/libmyhello.so
• gcc -c hello.cgcc编译得到.o文件
• ar -cr libmyhello.a hello.o创建静态库
• gcc -shared -fPIC -o libmyhello.so hello.o创建动态库
  再次使用gcc使用库运行时发现如上动态库的问题
  
  说明当动态库与静态库同时存在时，优先使用动态库。

实例使用库1

参照hello使用库过程
a1.c代码

#include<stdio.h>
void a1(int n)
{
	int x;
	x=n+2;
	printf("%d\n",x);
}

a2.c代码

#include<stdio.h>
void a2(int n)
{
	int x;
	x=n*n-2;
	printf("%d\n",x);
}

a.h代码

#ifndef A_H
#define A_H
void a1(int n);
void a2(int n);
#endif

test.c代码

#include<stdio.h>
#include"a.h"
int main()
{
	a1(3);
	a2(3);
	return 0;
}

生成并使用静态库

生成并使用动态库

静态库与动态库文件对比

输入ll

发现静态库相较于动态库要小很多

二、编写一个c程序，重温全局常量、全局变量、局部变量、静态变量、堆、栈等概念，在Ubuntu系统和stm32(keil)中分别进行编码、验证。

全局变量

在所有函数外部定义的变量称为全局变量（Global Variable），它的作用域默认是整个程序，也就是所以的源文件。

局部变量，

定义在函数内部的变量称为局部变量（Local Variable）,它的作用域仅限于函数内部，离开该函数的内部就是无效的，在使用就会报错。

堆(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;
}
 

Ubuntu演示

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是在编译时就确定的； 但是，在以后的存取中，在栈上的数组比指针所指向的字符串(例如堆)快。

三、总结

1.通过对gcc生成静态库和动态库的学习，了解了静电库与动态库最本质的区别在于静态库在编译的时候会直接整合到目标程序中，而动态库不会，同时，动态库占用内存比静态库大得多，且优先使用动态库。
2.一般而言，程序内变量在堆栈上的分配，栈是由高地址到低地址，堆是由低地址到高地址。