Linux库

一、引言

通常情况下，对函数库的链接是放在编译时期（compile time）完成的。所有相关的对象文件（object file）与牵涉到的函数库（library）被链接合成一个可执行文件（executable file）。程序在运行时，与函数库再无瓜葛，因为所有需要的函数已拷贝到自己门下。所以这些函数库被成为静态库（static libaray），通常文件名为“l ibxxx.a ”的形式。 另外，我们也可以把对一些库函数的链接载入推迟到程序运行，这种库称之为动态库。

二.静态库

编译静态库

编译静态库很简单。

比如： gcc robin.c -c -L. -lRobinDynamic -o robin.o

注意，这里一定要加-c选项,不然如果的代码中没有Main函数的话，就编译不过。

这里-L. -lRobinDynamic表示在当前目录下搜寻RobinDynamic库，并载入它。该库可以是静态，也可以是动态的。编译静态库或编译动态库时，对库的搜寻和载入都一样，因此关于此 部分的知识请参照《 linux动态库 》

注意 ：如果要使用多个库的话，可以如下形式： gcc test.c -L. -lRobin -lRobinDynamic -o test.exe

打包静态库

编译完成，我需要用ar命令对生成的目标文件进行打包，以便使用。

ar命令选项 如下:

d  -----从指定的静态库文件中删除文件

m  -----把文件移动到指定的静态库文件中

p  -----把静态库文件中指定的文件输出到标准输出

q  -----快速地把文件追加到静态库文件中

r  -----把文件插入到静态库文件中

t - ----显示静态库文件中文件的列表

x  -----从静态库文件中提取文件

还有多个修饰符修改以上基本选项,详细请man ar 以下列出三个:

         a  -----把新的目标文件(*.o)添加到静态库文件中现有文件membername之后，如果没有membername项就表示所有现有文件之后

         b  -----把新的目标文件(*.o)添加到静态库文件中现有文件membername之前，如果没有membername项就表示所有现有文件之前

         c  ----- 创建一个新的.a文件

         v  -----使用详细模式，该模式下，将显示你添加的所有文件。

ar命令的命令行格式如下:

     ar [-]{dmpqrtx}[abcfilNoPsSuvV] [membername] [count] archive files...

参数 archive 定义 库的名称 ,  files 是你向库文件要 添加的目标文件的清单 , 用 空格分隔 每个文件.

比如目标文件添加到一个静态库文件的命令如下:

     ar r libapue.a error.o errorlog.o lockreg.o

如果此次该静态文件库还不存在的话，它会先创建它再添加目标文件。

如果我们想新建一个静态库（如果有，先删除）的话，可以用如下的命令：

ar crv libRobin.a robin.o libRobinDynamic.so

这样就了创建了librobin.a静态库文件, 你可以用 t 选项显示包含在库中的文件

创建库文件之后,可以创建这个静态库文件的索引来帮助提高和库连接的其他程序的编译速度.

使用ranlib程序创建库的索引,索引存放在库文件内部.

ranlib libapue.a

用nm命令可以进行显示目标文件或.so文件的符号，系统必须依靠这些符号找到其对应的代码地址，然后执行这些代码。

nm命令用于显示.a存档文件的时候,它将显示.a中所有目标文件或.so文件的符号

显示目标文件的符号,可用如下命令:

nm robin.o | more

0000000000000000 T sayHello

                 U sayHelloWorld

显示.so文件的符号，可用如下命令

nm libRobinDynamic.so

0000000000200e50 a _DYNAMIC

0000000000200fe8 a _GLOBAL_OFFSET_TABLE_

                 w _Jv_RegisterClasses

0000000000200e30 d __CTOR_END__

0000000000200e28 d __CTOR_LIST__

0000000000200e40 d __DTOR_END__

0000000000200e38 d __DTOR_LIST__

0000000000000670 r __FRAME_END__

0000000000200e48 d __JCR_END__

0000000000200e48 d __JCR_LIST__

0000000000201018 A __bss_start

                 w __cxa_finalize@@GLIBC_2.2.5

00000000000005c0 t __do_global_ctors_aux

0000000000000500 t __do_global_dtors_aux

0000000000201010 d __dso_handle

                 w __gmon_start__

0000000000201018 A _edata

0000000000201028 A _end

00000000000005f8 T _fini

0000000000000498 T _init

00000000000004e0 t call_gmon_start

0000000000201018 b completed.7424

0000000000201020 b dtor_idx.7426

0000000000000580 t frame_dummy

                 U puts@@GLIBC_2.2.5

00000000000005ac T sayHelloWorld

如果用nm命令对.a存档文件进行操作的时候,它将显示.a中所有目标文件或.so文件的符号。

命令如下：

nm libapue.a | more

使用静态库

使用静态库，只有在编译时才需要，运行时就不要需要了。

使用静态库，在进行编译时，可以和使用动态库一样进行使用，因此关于此部分的知识请参照《 linux动态库 》

另外，如果要使用多个库的话，可以如下形式 ： gcc test.c -L. -lRobin -lRobinDynamic -o test.exe

另外也可以以如下形式使用静态库：

gcc test.cpp –o  test.exe   libexample.a

使用静态库进行编译时需要注意如下事项:

1） 编译时，静态库如果不放在-l项中，那么一定要放在最后。

如：(在-o后面)

gcc test.cpp –o test.exe  libexample.a

2） 使用静态库时一定要连接所有用到的静态库，有多个静态库时，应该按照从新到旧（越底层越后面）的顺序进行排列

如要使用libwinkeemq-cpp.a,由于libwinkeemq-cpp.a用到了libactivemq-cpp.a，

而libactivemq-cpp.a又用到了libpthread.a, libuuid.a等等库。

其命令应如下：

gcc test.cpp –o test.exe  libwinkeemq-cpp.a lib libactivemq-cpp.a libpthrea.a libuuid.a…

3） 静态库和动态库结合使用。

这时动态库应该放到静态库前面，动态库按照从旧到新（越底层越前面）的顺序排列。

比如： gcc test.cpp  –L/usr/local/lib   –lactivemq-cpp –lrobin  –o test.exe  libwinkeemq-cpp.a

这里activemq-cpp就比robin更底层，即robin库会使用activemq-cpp库

三. 动态库

动态链接库的特点与优势

首先让我们来看一下，把库函数推迟到程序运行时期载入的好处：

1. 可以实现进程之间的资源共享。

什么概念呢？就是说，某个程序的在运行中要调用某个动态链接库函数的时候，操作系统首先会查看所有正在运行的程序，看在内存里是否已有此库函数的拷贝了。如果有，则让其共享那一个拷贝；只有没有才链接载入。这样的模式虽然会带来一些“动态链接”额外的开销，却大大的节省了系统的内存资源。C的标准库就是动态链接库，也就是说系统中所有运行的程序共享着同一个C标准库的代码段。

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

用户只需要升级动态链接库，而无需重新编译链接其他原有的代码就可以完成整个程序的升级。Windows 就是一个很好的例子。

3. 甚至可以真正坐到链接载入完全由程序员在程序代码中控制。

程序员在编写程序的时候，可以明确的指明什么时候或者什么情况下，链接载入哪个动态链接库函数。你可以有一个相当大的软件，但每次运行的时候，由于不同的操作需求，只有一小部分程序被载入内存。所有的函数本着“有需求才调入”的原则，于是大大节省了系统资源。比如现在的软件通常都能打开若干种不同类型的文件，这些读写操作通常都用动态链接库来实现。在一次运行当中，一般只有一种类型的文件将会被打开。所以直到程序知道文件的类型以后再载入相应的读写函数，而不是一开始就将所有的读写函数都载入，然后才发觉在整个程序中根本没有用到它们。

动态链接库的创建

由于动态链接库函数的共享特性，它们不会被拷贝到可执行文件中。在编译的时候，编译器只会做一些函数名之类的检查。在程序运行的时候，被调用的动态链接库 函数被安置在内存的某个地方，所有调用它的程序将指向这个代码段。因此，这些代码必须实用相对地址，而不是绝对地址。在编译的时候，我们需要告诉编译器， 这些对象文件是用来做动态链接库的，所以要用地址无关代码（Position Independent Code （PIC））选项。

对gcc编译器，只需添加上 -fPIC 标签，如：

gcc -fPIC -c file1.c

gcc -fPIC -c file2.c

gcc -shared libxxx.so file1.o file2.o

注意到最后一行，-shared 标签告诉编译器这是要建立动态链接库，这与静态链接库的建立很不一样。也注意到，动态链接库的名字形式为 “libxxx.so” 后缀名为 “.so”

四、动态链接库的使用

使用动态链接库，首先需要在编译期间让编译器检查一些语法与定义。

这与静态库的实用基本一样，用的是 -Lpath 和 -lxxx 标签。如：

gcc file1.o file2.o -L path  -l xxx  -o program.exe

编译器会先在path文件夹下搜索libxxx.so文件，如果没有找到，继续搜索libxxx.a（静态库）。

如果要使用多个库的话，可以如下形式：gcc test.c -L. -lRobin -lRobinDynamic -o test.exe

在程序运行期间，也需要告诉系统去哪里找你的动态链接库文件。对于elf格式的可执行程序，是由ld-linux.so*来完成的，它先后搜索elf文件的 DT_RPATH段-> 环境变量 LD_LIBRARY_PATH-> /etc/ld.so.conf目录列表 - > /lib/,/usr/lib目录 找到库文件后将其载入内存。一般的话，直接把你的动态链接库文件拷贝到/lib/,/usr/lib目录，或者通过  elf文件的  DT_RPATH段 或 LD_LIBRARY_PATH 环境变量 来设置你的动态链接库所在的目录，目录之间用" ; "或" : "进行分割，如： export LD_LIBRARY_PATH="lib;lib2"

在 /etc/ld.so.conf 文件中可以配置共享库（动态库）的搜索目录， /etc/ld.so.cache 只是它的一个副本，它反映了/etc/ld.so.conf配置的共享库（动态库）的搜索目录，系统真正读取是该文件。 但是我们不能直接编辑/etc/ld.so.cache文件，只能编辑/etc/ld.so.conf，然后使用ldconfig命令更新其到文件/etc/ld.so.cache， 如果您对/etc/ld.so.conf 文件进行 cat 操作，您可能会看到一个与下面类似的清单：

　　 $ cat /etc/ld.so.conf

　　/usr/X11R6/lib

　　/usr/lib/gcc-lib/i686-pc-linux-gnu/2.95.3

　　/usr/lib/mozilla

　　/usr/lib/qt-x11-2.3.1/lib

　　/usr/local/lib

ld.so.conf  文件包含一个所有目录（/lib 和 /usr/lib 除外，它们会自动包含在共享库搜寻目录中）的清单，动态装入器将在其中查找共享库。

你可以把你自己的动态库目录加入到 /etc/ld.so.conf ，并保存，然后使用l dconfig命令 ，这时您对 /etc/ld.so.conf 所做的更改才会反映到/etc/ld.so.cache。 从这一刻起，动态装入器在寻找共享库时会在/etc/ld.so.conf 中指定的所有新目录中进行搜寻。

另外注意， 使用"ldconfig -p | less"命令可以“看到”的所有共享库 。

一切安排妥当后，你可以用 ldd 命令检查是否连接正常。

ldd program.exe

动态链接库*.so的编译与使用

动态库*.so在linux下用c和c++编程时经常会碰到，最近在网站找了几篇文章介绍动态库的编译和链接，总算搞懂了这个之前一直不太了解得东东，这里做个笔记，也为其它正为动态库链接库而苦恼的兄弟们提供一点帮助。

1、动态库的编译

下面通过一个例子来介绍如何生成一个动态库。这里有一个头文件：so_test.h，三个.c文件：test_a.c、test_b.c、test_c.c，我们将这几个文件编译成一个动态库：libtest.so。

示例1

so_test.h：

#ifndef so_test

#define sotest

#include <stdio.h>

void test_a();

void test_b();

void test_c();

#endif

test_a.c：

#include "so_test.h"

void test_a()

{

printf("this is in test_a...\n");

}

test_b.c：

#include "so_test.h"

void test_b()

{

printf("this is in test_b...\n");

}

test_a.c：

#include "so_test.h"

void test_c()

{

printf("this is in test_c...\n");

}

将这几个文件编译成一个动态库：libtest.so

$ gcc test_a.c test_b.c test_c.c -fPIC -shared -o libtest.so

2、动态库的链接

在 示例1 中，我们已经成功生成了一个自己的动态链接库libtest.so，下面我们通过一个程序来调用这个库里的函数。程序的源文件为：test.c。

test.c：

#include "so_test.h"

int main()

{

test_a();

test_b();

test_c();

return 0;

}

通过如下命令，可以 将test.c与动态库libtest.so链接生成执行文件test：

$ gcc test.c -L. -ltest -o test

可以通过如下命令，测试是否动态连接，如果列出libtest.so，那么应该是连接正常了

$ ldd test

我们可以用 ldd 命令来确定某一特定可执行程序 是否为静态链接的

# ldd /sbin/sln

not a dynamic executable

“not a dynamic executable”是 ldd 说明 sln 是静态链接的一种方式。

3、编译参数解析

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

-shared： 该选项指定生成动态连接库（让连接器生成T类型的导出符号表，有时候也生成弱连接W类型的导出符号），不用该标志外部程序无法连接。相当于一个可执行文件

-fPIC：表示编译为位置独立的代码，不用此选项的话编译后的代码是位置相关的所以动态载入时是通过代码拷贝的方式来满足不同进程的需要，而不能达到真正代码段共享的目的。

-L.：表示要连接的库在当前目录中。如果是-Lpath的话，表示在path目录中查找库。

-ltest：表示需要名字为test的动态连接库，注意动态链接库文件的的名字为lib+动态链接库名字+.so的形式

LD_LIBRARY_PATH  这个环境变量系统表示默认的动态连接器的装载路径。 在程序运行期间，它告诉系统去哪里找你的动态链接库文件。

当然如果有root权限的话，可以修改/etc/ld.so.conf文件，然后调用 /sbin/ldconfig来达到同样的目的，不过如果没有root权限，那么只能采用输出LD_LIBRARY_PATH的方法了。

4、注意

调用动态库的时候有几个问题会经常碰到，有时，明明已经将库的头文件所在目录 通过 “-I” include进来了，库所在文件通过 “-L”参数引导，并指定了“-l”的库名，但通过ldd命令察看时，就是死活找不到你指定链接的so文件，这时你要作的就是通过修改 LD_LIBRARY_PATH或者/etc/ld.so.conf文件来指定动态库的目录。通常这样做就可以解决库无法链接的问题了。