Linux C 静态库和动态库

这次分享的宗旨是——让大家学会创建与使用静态库、动态库，知道静态库与动态库的区别，知道使用的时候如何选择。这里不深入介绍静态库、动态库的底层格式，内存布局等，有兴趣的同学，推荐一本书《程序员的自我修养——链接、装载与库》。

什么是库

库是写好的现有的，成熟的，可以复用的代码。现实中每个程序都要依赖很多基础的底层库，不可能每个人的代码都从零开始，因此库的存在意义非同寻常。

本质上来说库是一种可执行代码的二进制形式，可以被操作系统载入内存执行。库有两种：静态库（.a、.lib）和动态库（.so、.dll）。

所谓静态、动态是指链接。回顾一下，将一个程序编译成可执行程序的步骤：

图：编译过程

静态库

之所以成为【静态库】，是因为在链接阶段，会将汇编生成的目标文件.o与引用到的库一起链接打包到可执行文件中。因此对应的链接方式称为静态链接。

试想一下，静态库与汇编生成的目标文件一起链接为可执行文件，那么静态库必定跟.o文件格式相似。其实一个静态库可以简单看成是一组目标文件（.o/.obj文件）的集合，即很多目标文件经过压缩打包后形成的一个文件。

静态库特点总结：

1. 静态库对函数库的链接是放在编译时期完成的。

2. 程序在运行时与函数库再无瓜葛，移植方便。

3. 浪费空间和资源，因为所有相关的目标文件与牵涉到的函数库被链接合成一个可执行文件。

 

Linux下使用ar工具、Windows下vs使用lib.exe，将目标文件压缩到一起，并且对其进行编号和索引，以便于查找和检索。一般创建静态库的步骤如图所示：

图：创建静态库过程

Linux下创建与使用静态库

Linux静态库命名规则

Linux静态库命名规范，必须是"lib[your_library_name].a"：lib为前缀，中间是静态库名，扩展名为.a。

创建静态库（.a）

通过上面的流程可以知道，Linux创建静态库过程如下：

// add.c
int add(int a, int b)
{
   return (a+b);
}

      l  首先，将代码文件编译成目标文件.o（add.o）

gcc -c add.c

注意带参数-c，否则直接编译为可执行文件

l  然后，通过ar工具将目标文件打包成.a静态库文件

ar -crv libadd.a add.o

生成静态库libadd.a。

大一点的项目会编写makefile文件（CMake等等工程管理工具）来生成静态库，输入多个命令太麻烦了。

使用静态库

编写使用上面创建的静态库的测试代码：

// main.c
#include<stdio.h>

extern int add(int a, int b);
int main(void)
{
   int n = add(3,4);
   printf("add(3,4) = %d \n",n);

   return 0;
}


测试：
1.  gcc main.c -ladd -o add
这种如果在当前目录下能找到静态库，否则要设置路径，一般用 -L 选项后面跟路径
    gcc main.c -L. -ladd -o add 

2. 直接 gcc main.c libadd.a -o add

3. 如果同时有相同名字的静态和动态库，如果想使用静态库 要加上-static：可强制编译时使用静态库，
   -Bdynamic 是强制使用动态。 如果不使用这个参数，而静态库与动态库同名的话，会优先使用动态库

 -L：表示要连接的库所在目录

 -l：指定链接时需要的动态库，编译器查找动态连接库时有隐含的命名规则，即在给出的名字前面加上lib，后面加上.a或.so来确定库的名称。

 

动态库

通过上面的介绍发现静态库，容易使用和理解，也达到了代码复用的目的，那为什么还需要动态库呢？

为什么还需要动态库？

为什么需要动态库，其实也是静态库的特点导致。

1. 空间浪费是静态库的一个问题。

2. 另一个问题是静态库对程序的更新、部署和发布页会带来麻烦。如果静态库liba.lib更新了，所以使用它的应用程序都需要重新编译、发布给用户（对于玩家来说，可能是一个很小的改动，却导致整个程序重新下载，全量更新）。

动态库在程序编译时并不会被连接到目标代码中，而是在程序运行是才被载入。不同的应用程序如果调用相同的库，那么在内存里只需要有一份该共享库的实例，规避了空间浪费问题。动态库在程序运行是才被载入，也解决了静态库对程序的更新、部署和发布页会带来麻烦。用户只需要更新动态库即可，增量更新。

动态库特点总结：

1. 动态库把对一些库函数的链接载入推迟到程序运行的时期。

2. 可以实现进程之间的资源共享。（因此动态库也称为共享库）

3. 将一些程序升级变得简单。

4. 甚至可以真正做到链接载入完全由程序员在程序代码中控制（显示调用）。

Window与Linux执行文件格式不同，在创建动态库的时候有一些差异。

在Windows系统下的执行文件格式是PE格式，动态库需要一个DllMain函数做出初始化的入口，通常在导出函数的声明时需要有_declspec(dllexport)关键字。

Linux下gcc编译的执行文件默认是ELF格式，不需要初始化入口，亦不需要函数做特别的声明，编写比较方便。

与创建静态库不同的是，不需要打包工具（ar、lib.exe），直接使用编译器即可创建动态库。

 

Linux下创建与使用动态库

linux动态库的命名规则

动态链接库的名字形式为 libxxx.so，前缀是lib，后缀名为“.so”。

l  针对于实际库文件，每个共享库都有个特殊的名字“soname”。在程序启动后，程序通过这个名字来告诉动态加载器该载入哪个共享库。

l  在文件系统中，soname仅是一个链接到实际动态库的链接。对于动态库而言，每个库实际上都有另一个名字给编译器来用。它是一个指向实际库镜像文件的链接文件（lib+soname+.so）。

创建动态库（.so）

l  首先，生成目标文件，此时要加编译器选项-fpic

gcc -fPIC -c add.c

-fPIC 创建与地址无关的编译程序（pic，position independent code），是为了能够在多个应用程序间共享。

l  然后，生成动态库，此时要加链接器选项-shared

gcc -shared -o libadd.so add.o

-shared指定生成动态链接库。

     上面可以合成一句:

gcc -shared -fPIC add.c -o libadd.so

这里说明下 -fPIC 和 - fpic 的区别：

-fPIC 产生的代码要大， -fpic 产生的代码相对小，而且快，那为什么不是要 -fpic？

原因是，由于地址无关代码都是跟硬件平台相关的，不同的平台有着不同的实现，-fpic 在某些平台会有一些限制。

所以绝大部分情况我们使用 -fPIC 产生地址无关代码。

 

查看一个SO是否为动态库：

  readelf -d xxx.so | grep TEXTREL

如果上面的命令有任何输出，那么 xxx.so 就不是PIC, 否则就是PIC的，PIC的 SO是不会包含任何代码段重定位表的

TEXTREL 表示代码段重定位表地址。

 

使用动态库

编写使用动态库的测试代码：

代码和上面的 静态库一样，这里不再重复。来看下编译情况：

gcc main.c  -ladd -o add 
这里再当前目录下能找到，如果不在当前目录下，编译会出错
/usr/bin/ld: cannot find -ladd
collect2: error: ld returned 1 exit status

所以这里也有几种解决方法：
1. 和静态库一样设置 LIBRARY_PATH 路径。
2. 通过 -L 选项去设置路径也和静态一样。
gcc main.c  -Lxxx -ladd -o add


但是此时运行会出现错误
./add: error while loading shared libraries: libadd.so: cannot open shared object file: No such file or directory

我们可以通过 ldd add 查看：

ldd add 

        linux-vdso.so.1 =>  (0x00007ffec790d000)
        libadd.so => not found
        libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007eff52f32000)
        /lib64/ld-linux-x86-64.so.2 (0x000055a96247c000)

可以看到 libadd.so 虽然编译的时候找到了，但是运行装载时候找不到 not found

这是时候我们可以通过设置 LD_LIBRARY_PATH 如 export LD_LIBRARY_PATH =. 
这个只对动态库有用，静态不需要设置。
这时候再来看下

ldd add
        linux-vdso.so.1 =>  (0x00007ffd6cf2f000)
        libadd.so => ./libadd.so (0x00007f58ca33b000)
        libc.so.6 => /lib/x86_64-linux-gnu/libc.so.6 (0x00007f58c9f5f000)
        /lib64/ld-linux-x86-64.so.2 (0x00005561b2dbf000)

可以看到找到了。

当然如果我们用的时候嫌麻烦，可以直接放到系统PATH 路径下面，就不需要设置上面的各种路径。

那么，在执行的时候是如何定位共享库文件的呢？

如何让系统能够找到它：

      1.  查找 LD_LIBRARY_PATH 环境变量设置。

2. 如果安装在其他目录，需要将其添加到/etc/ld.so.cache文件中，步骤如下：

① 编辑/etc/ld.so.conf文件，加入库文件所在目录的路径

② 运行ldconfig ，该命令会重建/etc/ld.so.cache文件

      3. 如果安装在/lib或者/usr/lib下，那么ld默认能够找到，无需其他操作。

 

加载流程：

首先操作系统（内核）会读取可执行文件的头部，检查文件的合法性，然后从头部中的 ”Program Header” 中读取每个“Segment”的虚拟地址、文件地址和属性，并将它们映射到进程虚拟地址空间的相应位置，然后返回用户空间。将控制权交给程序的入口。

接下来静态和动态库就有区别了：

1. 静态链接的情况下，操作系统接着就可以把控制权转交给可执行文件的入口地址，然后程序开始执行。

2. 但是动态链接的情况下，操作系统还不能在装载完可执行文件之后把控制权交给可执行文件，因为我们知道可执行文件依赖于很多共享对象。这时候，可执行文件里面对于很多外部符号的引用还处于无效地址状态，既还没有跟相应的共享对象中的实际位置链接起来。所以在映射完可执行文件之后，操作系统会先启动一个动态链接库（Dynamic Linker）。分析.interp 段 ，在Linux下，动态链接器ld.so 实际上是一个共享对象（软链接），是一个特殊的共享对象，还是一个可执行的程序。操作系统同样通过映射的方式将它加载到进程的地址空间中。操作系统在加载完动态链接器之后，就将控制权交给动态链接器的入口地址。当动态链接器得到控制权之后，它开始执行一系列自身的初始化操作（自举，根据本身的 GOT 进行重定位），然后根据当前的环境参数，开始对可执行文件进行动态链接工作。当所有动态链接工作完成以后，动态链接器会将控制权转交到可执行文件的入口地址，程序开始正式执行。

 

1. 动态链接器本身是动态链接的还是静态链接？

动态链接器本身是静态链接，它不能依赖于其他共享对象。

ldd /lib/ld-linux.so.2 
     statically linked

2. 动态连接器本身必须是PIC的吗？

可以不是，但是PIC更加简单。如果不是PIC的话，会使得代码段无法共享，浪费内存。另一方面也会使ld.so本身初始化更加复杂。因为自举时还需要对代码段进行重定位。 实际上的 ld-linux.so.2 是PIC的。

3. 动态链接器可以被当做可执行文件运行。那么它的装载地址应该是多少？

ld.so的装载地址跟一般的共享对象没区别。即为 0x00000000,这个装载地址是一个无效的地址。作为一个共享库，内核在装载它时候会为其选择一个合适的装载地址。

4. 查看动态链接器的路径

readelf -l add | grep interpreter
[Requesting program interpreter: /lib64/ld-linux-x86-64.so.2]

objdump -s add
add:     file format elf64-x86-64

Contents of section .interp:
 400238 2f6c6962 36342f6c 642d6c69 6e75782d  /lib64/ld-linux-
 400248 7838362d 36342e73 6f2e3200           x86-64.so.2. 

 

动态库的显式调用

上面介绍的动态库使用方法和静态库类似属于隐式调用，编译的时候指定相应的库和查找路径。其实，动态库还可以显式调用。【在C语言中】，显示调用一个动态库轻而易举！

在Linux下显式调用动态库

#include <dlfcn.h>，提供了下面几个接口：

l  void * dlopen( const char * pathname, int mode )：函数以指定模式打开指定的动态连接库文件，并返回一个句柄给调用进程。

l  void* dlsym(void* handle,const char* symbol)：dlsym根据动态链接库操作句柄(pHandle)与符号(symbol)，返回符号对应的地址。使用这个函数不但可以获取函数地址，也可以获取变量地址。

l  int dlclose (void *handle)：dlclose用于关闭指定句柄的动态链接库，只有当此动态链接库的使用计数为0时,才会真正被系统卸载。

l  const char *dlerror(void)：当动态链接库操作函数执行失败时，dlerror可以返回出错信息，返回值为NULL时表示操作函数执行成功。

显式调用须要包括头文件#include <dlfcn.h>。

涉及到以下几个函数：dlopen()、dlsym()、dlerror()、dlclose()。

dlopen（）函数以指定模式打开指定的动态链接库文件，并返回一个句柄给dlsym（）的调用进程。

使用dlclose（）来卸载打开的库。当动态链接库操作函数运行失败时，dlerror能够返回出错信息，返回值为
NULL时表示操作函数运行成功。

编译时候要增加 -ldl (指定dl库)
详细的函数原型例如以下：

void *dlopen(const char *filename, int flag);

char *dlerror(void);

void *dlsym(void *handle, const char *symbol);

int dlclose(void *handle);

dlopen以指定模式打开指定的动态连接库文件。并返回一个句柄给调用进程，dlerror返回出现的错误，dlsym
通过句柄和连接符名称获取函数名或者变量名，dlclose来卸载打开的库。
如果已经生成libcaculate.so库，里面定义了add(),sub(),mul(),div()等函数。这里给出调用演示样例：

#include <stdio.h>
#include <stdlib.h>
#include <dlfcn.h>

//动态链接库路径
#define LIB_CACULATE_PATH "./libcaculate.so"

//函数指针
typedef int (*CAC_FUNC)(int, int);

int main()
{
    void *handle;
    char *error;
    CAC_FUNC cac_func = NULL;

    //打开动态链接库
    handle = dlopen(LIB_CACULATE_PATH, RTLD_LAZY);
    if (!handle) {
    fprintf(stderr, "%s\n", dlerror());
    exit(EXIT_FAILURE);
    }

    //清除之前存在的错误
    dlerror();

    //获取一个函数
    *(void **) (&cac_func) = dlsym(handle, "add");
    if ((error = dlerror()) != NULL)  {
    fprintf(stderr, "%s\n", error);
    exit(EXIT_FAILURE);
    }
    printf("add: %d\n", (*cac_func)(2,7));

    cac_func = (CAC_FUNC)dlsym(handle, "sub");
    printf("sub: %d\n", cac_func(9,2));

    cac_func = (CAC_FUNC)dlsym(handle, "mul");
    printf("mul: %d\n", cac_func(3,2));

    cac_func = (CAC_FUNC)dlsym(handle, "div");
    printf("div: %d\n", cac_func(8,2));

    //关闭动态链接库
    dlclose(handle);
    exit(EXIT_SUCCESS);
}

 

显式调用C++动态库注意点

对C++来说，情况稍微复杂。显式加载一个C++动态库的困难一部分是因为C++的name mangling；另一部分是因为没有提供一个合适的API来装载类，在C++中，您可能要用到库中的一个类，而这需要创建该类的一个实例，这不容易做到。

name mangling可以通过extern "C"解决。C++有个特定的关键字用来声明采用C binding的函数：extern "C" 。用 extern "C"声明的函数将使用函数名作符号名，就像C函数一样。因此，只有非成员函数才能被声明为extern "C"，并且不能被重载。尽管限制多多，extern "C"函数还是非常有用，因为它们可以象C函数一样被dlopen动态加载。冠以extern "C"限定符后，并不意味着函数中无法使用C++代码了，相反，它仍然是一个完全的C++函数，可以使用任何C++特性和各种类型的参数。

另外如何从C++动态库中获取类，附上几篇相关文章，但我并不建议这么做：

l  《LoadLibrary调用DLL中的Class》：http://www.cppblog.com/codejie/archive/2009/09/24/97141.html

l  《C++ dlopen mini HOWTO》：http://blog.csdn.net/denny_233/article/details/7255673

“显式”使用C++动态库中的Class是非常繁琐和危险的事情，因此能用“隐式”就不要用“显式”，能静态就不要用动态。

附件：Linux下库相关命令

g++(gcc)编译选项

-shared ：指定生成动态链接库。

-static ：指定生成静态链接库。

-fPIC ：表示编译为位置独立的代码，用于编译共享库。目标文件需要创建成位置无关码， 念上就是在可执行程序装载它们的时候，它们可以放在可执行程序的内存里的任何地方。

-L. ：表示要连接的库所在的目录。

-l：指定链接时需要的动态库。编译器查找动态连接库时有隐含的命名规则，即在给出的名字前面加上lib，后面加上.a/.so来确定库的名称。

-Wall ：生成所有警告信息。

-ggdb ：此选项将尽可能的生成gdb 的可以使用的调试信息。

-g ：编译器在编译的时候产生调试信息。

-c ：只激活预处理、编译和汇编,也就是把程序做成目标文件(.o文件) 。 

-Wl,options ：把参数(options)传递给链接器ld 。如果options 中间有逗号,就将options分成多个选项,然后传递给链接程序。

 

nm命令

有时候可能需要查看一个库中到底有哪些函数，nm命令可以打印出库中的涉及到的所有符号。库既可以是静态的也可以是动态的。nm列出的符号有很多，常见的有三种：

1. 一种是在库中被调用，但并没有在库中定义(表明需要其他库支持)，用U表示；

2. 一种是库中定义的函数，用T表示，这是最常见的；

3. 一种是所谓的弱态”符号，它们虽然在库中被定义，但是可能被其他库中的同名符号覆盖，用W表示。

 

ldd命令

ldd命令可以查看一个可执行程序依赖的共享库。

 

总结

二者的不同点在于代码被载入的时刻不同。

1. 静态库在程序编译时会被连接到目标代码中，程序运行时将不再需要该静态库，因此体积较大。

2. 动态库在程序编译时并不会被连接到目标代码中，而是在程序运行是才被载入，因此在程序运行时还需要动态库存在，因此代码体积较小。

动态库的好处是，不同的应用程序如果调用相同的库，那么在内存里只需要有一份该共享库的实例。带来好处的同时，也会有问题！如经典的DLL Hell问题，关于如何规避动态库管理问题，可以自行查找相关资料。