Linux静态库和动态库的分析

痛定思痛。 2022-06-16 20:12 227阅读 0赞

**Linux****静态库和动态库的分析**

**1.什么是库**  
在windows平台和linux平台下都大量存在着库。  
本质上来说库是一种可执行代码的二进制形式，可以被操作系统载入内存执行。  
由于windows和linux的本质不同，因此二者库的二进制是不兼容的。  
本文仅限于介绍linux下的库。

**2.库的种类**  
linux下的库有两种：静态库和共享库（动态库）。  
二者的不同点在于代码被载入的时刻不同。  
静态库的代码在编译过程中已经被载入可执行程序，因此体积较大。  
共享库的代码是在可执行程序运行时才载入内存的，在编译过程中仅简单的引用，因此代码体积较小。

**3.库存在的意义**  
库是别人写好的现有的，成熟的，可以复用的代码，你可以使用但要记得遵守许可协议。  
现实中每个程序都要依赖很多基础的底层库，不可能每个人的代码都从零开始，因此库的存在意义非同寻常。  
共享库的好处是，不同的应用程序如果调用相同的库，那么在内存里只需要有一份该共享库的实例。

**4.库文件是如何产生的**  
在linux下,静态库的后缀是.a，它的产生分两步：  
Step 1.由源文件编译生成一堆.o，每个.o里都包含这个编译单元的符号表。  
Step 2.ar命令将很多.o转换成.a，成为静态库。  
动态库的后缀是.so，它由gcc加特定参数编译产生。  
例如:  
$ gcc -fPIC -c \*.c   
$ gcc -shared -Wl,-soname, libfoo.so.1 -o libfoo.so.1.0 \*.

**5.库文件是如何命名的，有没有什么规范**  
在linux下，库文件一般放在/usr/lib 下，  
静态库的名字一般为libxxxx.a，其中xxxx是该lib的名称  
动态库的名字一般为libxxxx.so.major.minor，xxxx是该lib的名称，major是主版本号，minor是副版本号。

**6.如何知道一个可执行程序依赖哪些库**  
ldd命令可以查看一个可执行程序依赖的共享库，  
例如\# ldd /bin/lnlibc.so.6  
=> /lib/libc.so.6 (0×40021000)/lib/ld-linux.so.2  
=> /lib/ld- linux.so.2 (0×40000000)  
可以看到ln命令依赖于libc库和ld-linux库

**7.可执行程序在执行的时候如何定位共享库文件**  
当系统加载可执行代码时候，能够知道其所依赖的库的名字，但是还需要知道绝对路径  
此时就需要系统动态载入器(dynamic linker/loader)。  
对于elf格式的可执行程序，是由ld-linux.so\*来完成的，它先后搜索elf文件的 DT\_RPATH段—环境变量LD\_LIBRARY\_PATH—/etc/ld.so.cache文件列表—/lib/,/usr/lib目录找到库文件后将其载入内存。

**8.在新安装一个库之后如何让系统能够找到他**  
如果安装在/lib或者/usr/lib下，那么ld默认能够找到，无需其他操作。  
如果安装在其他目录，需要将其添加到/etc/ld.so.cache文件中，步骤如下  
step1.编辑/etc/ld.so.conf文件，加入库文件所在目录的路径  
step2.运行ldconfig，该命令会重建/etc/ld.so.cache文件

** **

**9.****制作和使用静态或动态库**

我们通常把一些公用函数制作成函数库，供其它程序使用。函数库分为静态库和动态库两种。静态库在程序编译时会被连接到目标代码中，程序运行时将不再需要该静态库。动态库在程序编译时并不会被连接到目标代码中，而是在程序运行是才被载入，因此在程序运行时还需要动态库存在。本文主要通过举例来说明在Linux中如何创建静态库和动态库，以及使用它们。在创建函数库前，我们先来准备举例用的源程序，并将函数库的源程序编译成.o文件。

**第1步：编辑得到举例的程序\--hello.h、hello.c和main.c；**  
hello.h(见程序1)为该函数库的头文件。  
hello.c(见程序2)是函数库的源程序，其中包含公用函数hello，该函数将在屏幕上输出"Hello XXX!"。  
main.c(见程序3)为测试库文件的主程序，在主程序中调用了公用函数hello。   
程序1: hello.h  
\#ifndef HELLO\_H  
\#define HELLO\_H

void hello(const char \*name);

\#endif //HELLO\_H  
程序2: hello.c  
\#include

void hello(const char \*name)  
\{  
printf("Hello %s!\\n", name);  
\}  
程序3: 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   
\#   
(注1：本文不介绍各命令使用和其参数功能，若希望详细了解它们，请参考其他文档。)   
(注2：首字符"\#"是系统提示符，不需要键入，下文相同。)   
我们运行ls命令看看是否生存了hello.o文件。   
\# ls   
hello.c hello.h hello.o main.c   
\#   
(注3：首字符不是"\#"为系统运行结果，下文相同。)   
在ls命令结果中，我们看到了hello.o文件，本步操作完成。   
下面我们先来看看如何创建静态库，以及使用它。

**第3步：由.o文件创建静态库；**  
静态库文件名的命名规范是以lib为前缀，紧接着跟静态库名，扩展名为.a。例如：我们将创建的静态库名为myhello，则静态库文件名就是libmyhello.a。在创建和使用静态库时，需要注意这点。创建静态库用ar命令。   
在系统提示符下键入以下命令将创建静态库文件libmyhello.a。   
\# ar cr libmyhello.a hello.o   
\#   
我们同样运行ls命令查看结果：   
\# ls   
hello.c hello.h hello.o libmyhello.a main.c   
\#   
ls命令结果中有libmyhello.a。

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

下面先生成目标程序hello，然后运行hello程序看看结果如何。   
\# gcc -o hello main.c -L. -l myhello   
\# ./hello   
Hello everyone!   
\#   
我们删除静态库文件试试公用函数hello是否真的连接到目标文件 hello中了。   
\# rm libmyhello.a   
rm: remove regular file \`libmyhello.a'? y   
\# ./hello   
Hello everyone!   
\#   
程序照常运行，静态库中的公用函数已经连接到目标文件中了。

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

**第5步：由.o文件创建动态库文件**  
动态库文件名命名规范和静态库文件名命名规范类似，也是在动态库名增加前缀lib，但其文件扩展名为.so。例如：我们将创建的动态库名为myhello，则动态库文件名就是libmyhello.so。用gcc来创建动态库。   
在系统提示符下键入以下命令得到动态库文件libmyhello.so。   
\# gcc -shared -fPCI -o libmyhello.so hello.o   
\#   
我们照样使用ls命令看看动态库文件是否生成。   
\# ls   
hello.c hello.h hello.o libmyhello.so main.c   
\#

**第6步：在程序中使用动态库**  
在程序中使用动态库和使用静态库完全一样，也是在使用到这些公用函数的源程序中包含这些公用函数的原型声明，然后在用gcc命令生成目标文件时指明动态库名进行编译。我们先运行gcc命令生成目标文件，再运行它看看结果。   
\# gcc -o hello main.c -L. -l myhello   
\# ./hello   
./hello: error while loading shared libraries: libmyhello.so: cannot open shared object

file: No such file or directory   
\#   
哦！出错了。快看看错误提示，原来是找不到动态库文件libmyhello.so。程序在运行时，会在/usr/lib和/lib等目录中查找需要的动态库文件。若找到，则载入动态库，否则将提示类似上述错误而终止程序运行。我们将文件libmyhello.so复制到目录/usr/lib中，再试试。   
\# mv libmyhello.so /usr/lib   
\# ./hello   
./hello: error while loading shared libraries: /usr/lib/libhello.so: cannot restore segment

prot after reloc: Permission denied  
由于SELinux引起，  
\# chcon -t texrel\_shlib\_t /usr/lib/libhello.so  
\# ./hello  
Hello everyone!   
\#   
成功了。这也进一步说明了动态库在程序运行时是需要的。   
我们回过头看看，发现使用静态库和使用动态库编译成目标程序使用的gcc命令完全一样，那当静态库和动态库同名时，gcc命令会使用哪个库文件呢？抱着对问题必究到底的心情，来试试看。   
先删除 除.c和.h外的 所有文件，恢复成我们刚刚编辑完举例程序状态。   
\# rm -f hello hello.o /usr/lib/libmyhello.so   
\# ls   
hello.c hello.h main.c   
\#   
在来创建静态库文件libmyhello.a和动态库文件libmyhello.so。   
\# gcc -c hello.c   
\# ar cr libmyhello.a hello.o   
\# gcc -shared -fPCI -o libmyhello.so hello.o   
\# ls   
hello.c hello.h hello.o libmyhello.a libmyhello.so main.c   
\#   
通过上述最后一条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   
\#   
从程序hello运行的结果中很容易知道，当静态库和动态库同名时， gcc命令将优先使用动态库。

# Linux下静态库生成和使用 #

## 一.静态库概念 ##

1.库是预编译的目标文件(object  files)的集合，它们可以被链接进程序。静态库以后缀为”.a”的特殊的存档（archive file）存储。

2.标准系统库可在目录/usr/lib与/lib中找到。比如，在类Unix系统中C语言的数序库一般存储为文件/usr/lib/libm.a。该库中函数的原型声明在头文件/usr/include/math.h中。

3.C标准库本身存储为/usr/lib/libc.a，它包含ANS1/ISO标准指定的函数，比如printf。对每一个C程序来说，libc.a都默认被链接。

4.一个事例：

在程序中调用一个数序库libm.a中sin函数。

\#include<stdio.h>

\#include<math.h>

int  main()

double  x = 2.0;

double y = sin(x);

printf(“the result:%f\\n”,y);

return 0;

如果直接使用gcc tiger.c则会出现错误：

undefined  reference to ‘sin’;

1>函数sin(),未在本程序中定义也不在默认库’libc.a’中，除非被指定，编译器也不会链接’libm.a’。

2>为使编译器能将sin()链接进主程序‘test.c’,需要提供数学库’libm.a’.。

3>使用方法：

gcc  tiger.c /usr/lib/libm.a  -o tiger

则可以编译通过。为了避免在命令行中指定长的路径，编译器为链接函数库提供了快捷的选项’-l’。因此可以使用下面的方法：

gcc  tiger.c -lm –o tiger

注：选项-lNAME使用连接器尝试链接系统库目录中的函数库文件libNAME.a。

## 二.生成和使用静态库 ##

1.静态库是obj文件的一个集合，通常静态库以”.a”为后缀。静态库由程序ar生成。

2.静态库的优点是可以在不用重新编译程序库代码的情况下，进行程序的重新链接，这种方法节省了编译过程的时间（在编译大型程序的时候，需要花费很长的时间）。静态库的另一个优点是开发者可以提供库文件给使用的人员，不用开放源代码，这是库函数提供者经常采用的手段。

3.通过一个实例来了解如何自己生成静态库和使用静态库

首先生成静态库

1>在test文件夹下有三个文件:main.c ,tiger.c,tiger.h;

![0_13216210873F88.gif][]

a. main.c文件中的内容：

\#include<stdio.h>

\#include”tiger.h”

int  main(void)

printf(“sum=%d\\n”,add(3,5));

return 0;

b.tiger.h文件中的内容：

\#ifndef \_\_TIGER\_\_

\#define \_\_TIGER\_\_

int  add(int  a,int b);

\#endif

c.tiger.c文件中的内容

int  add(int  a,int b)

return a+b;

2>创建静态库的最基本步骤是生成目标文件tiger.o

gcc  -o tiger.o  -c  tiger.c

3>然后生成静态库libadd.a：

ar  -rcs libadd.a  tiger.o

其次使用静态库

1>使用gcc命令带上库文件就OK了

gcc  -o  main main.c  libadd.a

2> 也可以使用命令”-l库名”进行，库名是不包含库函数库和扩展名的字符串。

gcc  -o  main  main.c -ladd

上面的命令执行完后，系统返回：

Cannot  find –ladd

说明：上面的命令将在系统默认的路径西安查找add函数库，并把他链接到要生成的目标程序上。系统提示没有找到库文件add,这是由于add库函数没有在系统默认的查找路径下，我们需要认为指定库函数的路径，例如：库文件和当前编译文件在同一目录下：  
   gcc  -o main  main.c -L  ./  -ladd

系统就能正常生成可执行文件。

说明：

在使用-l选项时，-o选项的目的名要在-l链接的库名之前，否则gcc会认为-l是生成的目标而出错。

[0_13216210873F88.gif]: /images/20220617/8af8a07186d34cc3a7cd9079c1f697d5.png