静态库、共享库、动态库的创建和使用

通常库分为：静态库,共享库，动态加载库,。下面分别介绍。
一、 静态库：
1.概念：
静态库就是一些目标文件的集合，以.a结尾。静态库在程序链接的时候使用，链接器会将程序中使用
到函数的代码从库文件中拷贝到应用程序中。一旦链接完成，在执行程序的时候就不需要静态库了。
由于每个使用静态库的应用程序都需要拷贝所用函数的代码，所以静态链接的文件会比较大。
2.创建与应用:
首先创建库文件libhello.c

1     #include <stdio.h>
2     void hello()
3     {
4         printf("hello, welcome to library world!\n");
5     }

创建头文件libhello.h

1     void hello();

现在我们创建libhello静态库文件:
$ gcc -c libhello.c -o libhello.o
$ ar rcs libhello.a libhello.o
其中ar中的rcs的意思是： r表明将模块加入到静态库中，c表示创建静态库，s表示生产索引。

我们写一个测试程序:
$ cat test.c

1     #include <stdio.h>
2     int main(void)
3     {
4         printf("use library hello.\n");
5         hello();
6         return 0;
7     }

编译与链接：
$ gcc -c test.c -o test.o
$ gcc test.o -L. -lhello -o test
说明：-L.表示将当前目录加入到库搜索路径。默认的库搜索路径在/usr/lib目录下。
另外这里说明一下易混淆的参数-I, 它表示搜索头文件的路径。这样gcc在查找头文件的时候会首先到-I指定的目录查找，然后才是系统默认目录。

-l参数: -lname表示库搜索目录下的libname.a 或者libname.so文件 ,这也是为什么库文件都以lib开头的原因之一。一个惯例嘛。当然了，如果你的库文件不是libhello,而是hello. 那就不能用-l参数编译了。 可以这样：
gcc test.o -L. hello.a -o test
注意: $gcc -L. -lhello test.o -o test 会出错！。
原因是: -l是链接器选项，必须要放到被编译文件的后面。 所以上面的命令中-lhello一定要放到 test.o的后面。

运行：
$ ./test
use library hello.
hello, welcome to library world!

二、共享库:
1、共享库的概念：
共享库以.so结尾. (so == share object) 在程序的链接时候并不像静态库那样在拷贝使用函数的代码，而只是作些标记。然后在程序开始启动运行的时候，动态地加载所需模块。所以，应用程序在运行的时候仍然需要共享库的支持。 共享库链接出来的文件比静态库要小得多。

2、共享库的命名
一般一个共享库的有三个名字：soname, real-name, linker-name。下面先看实例:
$ ls -l /usr/lib/libncurses*
lrwxrwxrwx 1 root root 20 2008-05-25 13:54 libncurses.so -> /lib/libncurses.so.5
lrwxrwxrwx 1 root root 13 2008-05-26 15:18 libncurses.so.5 -> libtermcap.so

上面的libncurses.so.5就是soname, 其中ncurses是库名，5分别是主版本号(major)，
当然也可以有次版本号(minor)和发行号(release)。(类似于ibncurses.so.5.0.0)
.so当然表示共享库了。通常soname只是real name的一个链接。
而libtermcap.so 这是ncurse库的real-name, 也就是包含真是代码实现的文件. libncurses.so 则是linker name,用于应用程序链接的时候的一个搜索名。 它通常是soname的一个链接,形式为libname.so。

　实际上，每一个库都有一个soname，当连接器发现它正在查找的程序库中有这样一个名称，连接器便会将soname嵌入连结中的二进制文件内，而不是它正在运行的实际文件名，在程序执行期间，程序会查找拥有 soname名字的文件，而不是库的文件名，换句话说，soname是库的区分标志。这样做的目的主要是允许系统中多个版本的库文件共存，习惯上在命名库文件的时候通常与soname相同。

3、共享库的装载
(1) 在所有基于GNU glibc的系统(当然包括Linux)中，在启动一个ELF二进制执行程序时，
一个特殊的程序"程序装载器"会被自动装载并运行。在linux中，这个程序装载器就是
/lib/ld-linux.so.X(X是版本号)。它会查找并装载应用程序所依赖的所有共享库。
被搜索的目录保存在/etc/ls.so.conf文件中，但一般/usr/local/lib并不在搜索之列，至少debian/ubuntu是这样。这似乎是一个系统失误，只好自己加上了。当然，如果程序的每次启动，都要去搜索一番，势必效率不堪忍受。Linux系统已经考虑这一点，对共享库采用了缓存管理。ldconfig就是实现这一功能的工具，其缺省读取/etc/ld.so.conf文件，对所有共享库按照一定规范建立符号连接，然后将信息写入/etc/ld.so.cache。
/etc/ld.so.cache的存在大大加快了程序的启动速度。

(2) 当然你也可以通过设置环境变量LD_LIBRARY_PATH来设置ld的装载路径。这样装载器就会首先搜索该变量的目录，然后才是默认目录。但是记住，LD_LIBRARY_PATH是用于开发和测试的，你可以将一些用于测试的替代共享库的目录放到该变量中，类似于/etc/ld.so.preload的作用。但是该变量不应该用于正常用户的正常程序。

(3) 如果你不使用LD_LIBRARY_PATH环境变量，可以通过如下方式给装载器传入路径:
$ /lib/ld-linux.so.2 --library-path PATH EXECUTABLE


4、共享库的创建与应用
(1) 创建共享库:
gcc -fpic/fPIC -c source.c -o source.o
gcc -shared -Wl,-soname,your_soname -o library_name file_list library_list
说明: -fpic或者-fPIC表明创建position independent code，这通常是创建共享库必须的。
-Wl 表明给链接器传送参数，所以这里-soname, library_name 为给链接器的参数。
-shared 表明是使用共享库

下面是使用a.c和b.c创建共享库的示例：
gcc -fPIC -g -c -Wall a.c
gcc -fPIC -g -c -Wall b.c
gcc -shared -Wl,-soname, libmyab.so.1 -o libmyab.so.1.0.1 a.o b.o -lc
说明: lc == libc

几个需要注意的地方：
a.不推荐使用strip处理共享库，最好不要使用-fomit-frame-pointer编译选项
b.-fPIC和-fpic都可以产生目标独立代码，具体应用取决于平台，-fPIC是always work，
尽管其产生的目标文件可能会大些； -fpic产生的代码小，执行速度快，但可能有平台依赖限制。
c.一般情况下，-Wall,-soname,your_soname编译选项是需要的。当然，-share选项更不能丢。

(2) 安装使用共享库
一旦你创建好共享库后就需要安装使用了，最简单的办法是将库拷贝到默认目录下(/usr/lib)。
然后创建一些符号链接，最简单的方式还是使用ldconfig(8)来处理这里符号链接。最后是重新
编译链接你的程序,通过-L和-l参数指定库路径就可以了。



三、 动态加载库
1. 概念
动态加载库(dynamically loaded (DL) libraries)是指在程序运行过程中可以加载的函数库。而不是像共享库一样在程序启动的时候加载。DL对于实现插件和模块非常有用，因为他们可以让程序在允许时等待插件的加载。在Linux中，动态库的文件格式跟共享库没有区别，主要区别在于共享库是运行时加载。
有专门的一组API用于完成打开动态库，查找符号，处理出错，关闭动态库等功能。

下面对这些接口函数逐一介绍:
(1) dlopen
函数原型：void *dlopen(const char *libname,int flag);
功能描述：dlopen必须在dlerror，dlsym和dlclose之前调用，表示要将库装载到内存，准备使用。
如果要装载的库依赖于其它库，必须首先装载依赖库。如果dlopen操作失败，返回NULL值；如果库已经被装载过，则dlopen会返回同样的句柄。
参数中的libname一般是库的全路径，这样dlopen会直接装载该文件；如果只是指定了库名称，在dlopen会按照下面的机制去搜寻：
a.根据环境变量LD_LIBRARY_PATH查找
b.根据/etc/ld.so.cache查找
c.查找依次在/lib和/usr/lib目录查找。
flag参数表示处理未定义函数的方式，可以使用RTLD_LAZY或RTLD_NOW。RTLD_LAZY表示暂时不去处理未定义函数，先把库装载到内存，等用到没定义的函数再说；RTLD_NOW表示马上检查是否存在未定义的函数，若存在，则dlopen以失败告终。

(2) dlerror
函数原型：char *dlerror(void);
功能描述：dlerror可以获得最近一次dlopen,dlsym或dlclose操作的错误信息，返回NULL表示无错误。dlerror在返回错误信息的同时，也会清除错误信息。

(3) dlsym
函数原型：void *dlsym(void *handle,const char *symbol);
功能描述：在dlopen之后，库被装载到内存。dlsym可以获得指定函数(symbol)在内存中的位置(指针)。
如果找不到指定函数，则dlsym会返回NULL值。但判断函数是否存在最好的方法是使用dlerror函数，

(4) dlclose
函数原型：int dlclose(void *);
功能描述：将已经装载的库句柄减一，如果句柄减至零，则该库会被卸载。如果存在析构函数，则在dlclose之后，析构函数会被调用。

2. 使用实例
$cat dltest.c

 1  　　#include <stdlib.h>
 2     #include <stdio.h>
 3     #include <dlfcn.h>
 4 
 5     int main(int argc, char **argv)
 6     {
 7         void *handle;
 8         double (*cosine)(double);
 9         char *error;
10 
11         handle = dlopen ("/lib/libm.so.6", RTLD_LAZY);
12         if (!handle) {
13             fputs (dlerror(), stderr);
14             exit(1);
15         }
16 
17         cosine = dlsym(handle, "cos");
18         if ((error = dlerror()) != NULL)  {
19             fputs(error, stderr);
20             exit(1);
21         }
22 
23         printf ("%f\n", (*cosine)(2.0));
24         dlclose(handle);
25         return 0;
26
27     }   
28 

编译: $ gcc -o dltest dltest.c -ldl -Wall
运行: $ ./dltest
-0.416147

四、查看库中的符号

(1) nm命令可以查可能一个库中的符号

nm列出的符号有很多，常见的有三种，一种是在库中被调用，但并没有在库中定义(表明需要其他库支持)，用U表示；一种是库中定义的函数，用T表示，这是最常见的；另外一种是所谓的“弱态”符号，它们虽然在库中被定义，但是可能被其他库中的同名符号覆盖，用W表示。例如，假设开发者希望知道上文提到的hello库中是否定义了 printf():

$nm libhello.so |grep printf

U printf

U表示符号printf被引用，但是并没有在函数内定义，由此可以推断，要正常使用hello库，必须有其它库支持，再使用ldd命令查看hello依赖于哪些库：

$ldd hello

libc.so.6=>/lib/libc.so.6(0x400la000)

/lib/ld-linux.so.2=>/lib/ld-linux.so.2 (0x40000000)

从上面的结果可以继续查看printf最终在哪里被定义.

链接来自:http://www.cnblogs.com/ThinkingWorld/articles/1861249.html

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

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

so_test.h：

#include
#include
void test_a();
void test_b();
void test_c();

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;
}
l 将test.c与动态库libtest.so链接生成执行文件test：
$ gcc test.c -L. -ltest -o test
l 测试是否动态连接，如果列出libtest.so，那么应该是连接正常了
$ ldd test
l 执行test，可以看到它是如何调用动态库中的函数的。
3、编译参数解析
最主要的是GCC命令行的一个选项:
-shared 该选项指定生成动态连接库（让连接器生成T类型的导出符号表，有时候也生成弱连接W类型的导出符号），不用该标志外部程序无法连接。相当于一个可执行文件

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

l -L.：表示要连接的库在当前目录中

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

l LD_LIBRARY_PATH：这个环境变量指示动态连接器可以装载动态库的路径。

l 当然如果有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文件来指定动态库的目录。通常这样做就可以解决库无法链接的问题了。

此例子来自:http://topic.csdn.net/t/20061113/22/5155139.html