嵌入式系统开发02——Ubuntu系统下静态库与动态库文件的生成与使用

本文主要写到如何使用gcc生成和使用静态库和动态库，以及动态库和静态库之间的简单对比。

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

1、什么是库

库通俗的讲就是把一些常用的函数的目标文件打包在一起，提供相应的接口，便于程序员使用。库是写好的、现有的，成熟的，可以复用的代码。现实中每个程序都要依赖很多基础的底层库，不可能每个人的代码都从零开始，因此库的存在意义非同寻常。像我们中常用的输出printf函数。当我们在使用时并不关心其底层是如何实现，只是使用其来提高编写代码的效率。本质上来说库是一种可执行代码的二进制形式，可以被操作系统载入内存执行。

2、库的分类

库有两种：静态库（.a、.lib） 和 动态库（.so、.dll）。

3、静态库和动态库的区别

一个程序的生成可执行文件的过程如下：

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

1、静态库对函数库的链接是放在编译时期完成的。
2、程序在运行时与函数库没有关系。
3、浪费空间和资源，因为所有相关的目标文件与牵涉到的函数库被链接合成一个可执行文件。

动态库的特点：

1、动态库把对一些库函数的链接载入推迟到程序运行的时期。
2、可以实现进程之间的资源共享。（因此动态库也称为共享库）
3、 将一些程序升级变得简单。
4、甚至可以真正做到链接载入完全由程序员在程序代码中控制（显示调用）。

二者的不同点在于代码被载入的时刻不同。
1、静态库在程序编译时会被连接到目标代码中，程序运行时将不再需要该静态库，因此体积较大。
2、动态库在程序编译时并不会被连接到目标代码中，而是在程序运行是才被载入，因此在程序运行时还需要动态库存在，因此代码体积较小。
3、静态链接库中不能包含其他静态或动态链接库。但动态链接库中可以包含其他静态或动态链接库。

4、静态库和动态库的创建和使用

接下来我将通过举例来说明在Ubuntu系统下如何创建静态库和动库态，以及如何使用它们。

(1) 编辑生成例子程序 hello.h、hello.c 和 main.c

先创建一个作业目录，保存本次练习的文件。

mkdir test1
cd test1

然后用 vim 文本编辑器编辑生成所需要的 3 个文件。
hello.c 是函数库的源程序，其中包含公用函数 hello，该函数将在屏幕上输出"Hello XXX!"。hello.h 为该函数库的头文件。main.c为测试库文件的主程序，在主程序中调用了公用函数 hello。
分别输入vim hello.h，vim hello.c，vim main.c，然后分别将下面的代码写到对应的文件中。
hello.h:

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

hello.c:

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

main.c:

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

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

无论静态库，还是动态库，都是由 .o 文件创建的。因此，我们必须将源程序 hello.c 通过 gcc 先编译成 .o 文件。在系统提示符下键入以下命令得到 hello.o 文件。

gcc -c hello.c

我们运行 ls命令 看看是否生存了 hello.o 文件。

ls

在 ls 命令 结果中，我们看到了 hello.o 文件，本步操作完成。
下面我们先来看看如何创建静态库，以及使用它。

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

静态库文件名的命名规范是以 lib 为前缀，紧接着跟静态库名，扩展名为.a。 例如：我们将创建的静态库名为 myhello，则静态库文件名就libmyhello.a 。在创建和使用静态库时，需要注意这点。创建静态库用 ar 命令。在系统提示符下键入以下命令将创建静态库文件libmyhello.a。

 ar -crv libmyhello.a hello.o

我们同样运行 ls 命令查看结果：

ls

ls 命令 结果中有 libmyhello.a。

(4) 在程序中使用静态库

静态库制作完了，如何使用它内部的函数呢？
只需要在使用到这些公用函数的源程序中包含这些公用函数的原型声明，然后在用 gcc 命令 生成目标文件时指明静态库名，gcc 将会从静态库中将公用函数连接到目标文件中。注意，gcc 会在静态库名前加上前缀 lib，然后追加扩展名 .a 得到的静态库文件名来查找静态库文件。
在 main.c 中，我们包含了静态库的头文件 hello.h，然后在主程序 main 中直接调用公用函数 hello。下面先生成目标程序 hello，然后运行 hello 程序看看结果如何。
方法一：

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

自定义的库时，main.c 还可放在 -L. 和 –lmyhello 之间，但是不能放在它俩之后，否则会提示 myhello 没定义，但是是系统的库时，如 g++ -o main（-L/usr/lib） -lpthread main.cpp
就不出错。
方法二：

gcc main.c libmyhello.a -o hello

方法三：
先生成 main.o：

gcc -c main.c

再生成可执行文件：

gcc -o hello main.o libmyhello.a

动态库连接时也可以这样做。

我们使用方法一生成可执行文件，在命令行输入./hello，运行 hello，观察到输出了Hello everyone!。

接下来删除静态库文件试试公用函数 hello 是否真的连接到目标文件 hello 中了。

rm libmyhello.a
./hello

经过实验发现： 删除静态库文件后，程序任然能照常运行，说明静态库中的公用函数已经连接到目标文件中了。

我们继续看看如何在 Linux 中创建动态库。我们还是从.o 文件开始。

(5) 由.o 文件创建动态库文件

动态库文件名命名规范和静态库文件名命名规范类似，也是在动态库名增加前缀 lib，但其文件扩展名为 .so。 例如：我们将创建的动态库名为 myhello，则动态库文件名就是 libmyhello.so。
用 gcc 来创建动态库:
在系统提示符下键入以下命令得到动态库文件 libmyhello.so。

gcc -shared -fPIC -o libmyhello.so hello.o 
/*-o 不可少*/

我们照样使用 ls 命令 看看动态库文件是否生成。

发现通过 gcc 实现了动态库的创建

(6)在程序中使用动态库

在程序中使用动态库和使用静态库完全一样，也是在使用到这些公用函数的源程序中包含这些公用函数的原型声明，然后在用 gcc 命令 生成目标文件时指明动态库名进行编译。我们先运行 gcc 命令 生成目标文件，再运行它看看结果。

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

（或 gcc main.c libmyhello.so -o hello不会出错（没有 libmyhello.so 的话，会出错）但是接下来./hello 会提示出错
因为虽然连接时用的是当前目录的动态库，但是 程序运行时，是到/usr/lib和/lib等目录中查找需要的动态库文件。若找到，则载入动态库，否则将提示类似上述错误而终止程序运行 。
此时将文件 libmyhello.so 复制到目录/usr/lib中，就可以成功运行了

 mv libmyhello.so /usr/lib
 ./hello

输入 mv libmyhello.so /usr/lib时会提示“Permission denied”，表示移动动态库文件时需要root权限，只需要在命令前加上 sudo，将命令改为sudo mv libmyhello.so /usr/lib，再按照提示输入密码，就可以将文件 libmyhello.so 复制到目录/usr/lib中了

此时运行 hello 也可以实现。这也进一步说明了动态库在程序运行时是需要的。

(7) 当静态库和动态库同名时，gcc 命令会使用哪个库文件呢？

我们回过头看看，发现使用静态库和使用动态库编译成目标程序使用的 gcc 命令 完全一样，那当静态库和动态库同名时，gcc 命令会使用哪个库文件呢？抱着对问题必究到底的心情，来试试看。
先删除除 .c 和 .h 外的所有文件，恢复成我们刚刚编辑完举例程序状态。

sudo rm -f hello hello.o /usr/lib/libmyhello.so
ls

再来创建静态库文件 libmyhello.a 和动态库文件 libmyhello.so。

gcc -c hello.c
ar -cr libmyhello.a hello.o
gcc -shared -fPIC -o libmyhello.so hello.o
ls

通过上述最后一条 ls 命令 ，可以发现静态库文件 libmyhello.a 和动态库文件 libmyhello.so 都已经生成，并都在当前目录中。然后，我们运行 gcc 命令 来使用函数库 myhello 生成目标文件 hello ，并运行程序 hello。

gcc -o hello main.c -L. –lmyhello
./hello

可以发现，提示的是“./hello: error while loading shared libraries: libmyhello.so: cannot open shared object file: No such file or directory”，表示动态库和静态库同时同名存在时，优先使用动态库。因为程序运行时，是到/usr/lib和/lib等目录中查找需要的动态库文件，而此时的动态库位于 /test1目录下，所以会提示类似上述错误而终止程序运行，将文件 libmyhello.so 复制到目录/usr/lib中即可。当然，如果直接使用gcc main.c libmyhello.a -o hello命令的话，就是指定为静态库了

4、编译参数解析

最主要的是 GCC 命令行的一个选项:

参数	作用
-shared	指定生成动态连接库
-fPIC	表示编译为位置独立的代码，不用此选项的话编译后的代码是位置相关的所以动态载入时是通过代码拷贝的方式来满足不同进程的需要，而不能达到真正代码段共享的目的
-L.	表示要连接的库所在的目录
-l	编译器查找动态连接库时有隐含的命名规则，即在给出的名字前面加上 lib，后面加上.so 或.a 来确定库的名称 libmyhello.so 或 libmyhello.a。
LD_LIBRARY_PATH	这个环境变量指示动态连接器可以装载动态库的路径

二、实例展示

1、实例要求

（1）请编写一个主程序文件 main1.c 和一个子程序文件 sub1.c， 要求：子程序sub1.c 包含一个算术运算函数 float x2x（int a，int b），此函数功能为对两个输入整型参数做某个运算，将结果做浮点数返回；主程序main1.c，定义并赋值两整型变量，然后调用函数 x2x，将x2x的返回结果printf出来。
（2）在上述程序代码基础进行改编，除了x2x函数之外，再扩展写一个x2y函数（功能自定），main函数代码将调用x2x和x2y ；将这3个函数分别写成单独的3个 .c文件，并用gcc分别编译为3个.o 目标文件；将x2x、x2y目标文件用 ar工具生成1个 .a 静态库文件, 然后用 gcc将 main函数的目标文件与此静态库文件进行链接，生成最终的可执行程序，记录文件的大小。
（3）将x2x、x2y目标文件用 ar工具生成1个 .so 动态库文件, 然后用 gcc将 main函数的目标文件与此动态库文件进行链接，生成最终的可执行程序，记录文件的大小，并与之前做对比。

2、实现过程

（1）创建test2目录，来存储此次实例的文件

mkdir test2
cd test2

（2）通过vim编辑文件sub1.c、sub2.c、sub.h、mian.c，分别将下述代码写到对应的文件中去

编写sub1.c
x2x实现两个数相加

#include <stdio.h>
float x2x(int a, int b)
{
  return a+b;
}

编写sub2.c
x2y实现两个数相减

#include <stdio.h>
float x2y(int a, int b)
{
  return a-b;
}

编写sub.h

#ifndef SUB_H
#define SUB_H
float x2x(int a,int b);
float x2y(int a,int b);
#endif

编写main1.c

#include <stdio.h>
#include"sub.h"
int main()
{
  int a=10,b=8;
  float num1=0,num2=0;
  num1=x2x(a,b);
  num2=x2y(a,b);
  printf("a+b=%f\n",num1);
  printf("a-b=%f\n",num2);
  return 0;
}

（3）用gcc分别编译为3个.o 目标文件

gcc -c sub1.c
gcc -c sub2.c
gcc -c main.c
ls

（4）静态库文件的生成与使用

将x2x、x2y目标文件用 ar工具生成1个 .a 静态库文件：

ar -crv libsub.a sub1.o sub2.o
ls

用 gcc将 main函数的目标文件与此静态库文件进行链接，生成最终的可执行程序：

gcc -o count main.c -L. -lsub
ls
./count

记录文件的大小：

（5）动态库文件的生成与使用

将x2x、x2y目标文件用 ar工具生成1个 .so 动态库文件

gcc -shared -fPIC -o libsub.so sub1.o sub2.o
ls

将动态库文件 libsub.so 复制到目录/usr/lib中

 sudo mv libsub.so /usr/lib

用 gcc将 main函数的目标文件与此动态库文件进行链接，生成最终的可执行程序：

gcc -o count main.c -L. -lsub
./count

记录文件的大小：

（6）动态库与静态库作比较

通过比较发现静态库要比动态库要小很多，生成的可执行文件大小相同

三、总结

通过本次对静态库和动态库知识的学习和练习，我熟悉了Ubuntu系统下静态库和动态库的生成和使用方法，了解了静态库和动态库各自的优缺点。也注意到了动态库和静态库同时同名存在时会优先使用动态库，且这时需要把动态库文件拷贝到 /urs\lib下才能正常使用。

---

参考资料：
1.用gcc生成静态库和动态库
2.静态库与动态库的生成和使用
3.gcc生成静态库.a和动态库.so
4. gcc静态库和动态库的生成以及使用
5. 静态库和动态库的区别
6. 动态库与静态库的区别？优缺点？