meisw's blog

函数库分为静态库和动态库两种。创建Linux静态库和Linux动态库和使用它们在这里将以举例的形式详述一下。静态库在程序编译时会被连接到目标代码中，程序运行时将不再需要该静态库。动态库在程序编译时并不会被连接到目标代码中，而是在程序运行是才被载入，因此在程序运行时还需要动态库存在。

第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 <stdio.h> 
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

第3步：由.o文件创建静态库

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

# ar cr libmyhello.a hello.o

第4步：在程序中使用静态库

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

第6步：在程序中使用动态库

在程序中使用动态库和使用静态库完全一样，也是在使用到这些公用函数的源程序中包含这些公用函数的原型声明，然后在用gcc命令生成目标文件时指明动态库名进行编译。我们先运行gcc命令生成目标文件，再运行它看看结果。
# 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
#
哦！出错了。快看看错误提示，原来是找不到动态库文件libmyhello.so。程序在运行时，会在/usr/lib和/lib等目录中查找需要的动态库文件。若找到，则载入动态库，否则将提示类似上述错误而终止程序运行。我们将文件libmyhello.so复制到目录/usr/lib中，再试试。
# mv libmyhello.so /usr/lib
# ./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运行的结果中很容易知道，当Linux静态库和Linux动态库同名时， gcc命令将优先使用动态库。

如何查看静态库内容 Unix/Linux

以下从最好情况->最坏情况：

1. 最好知道静态库的原文件(.c)，要是知道声明文件(.h)也比较好。

2. ar -t YourFile 看其结构，找其中的原文件。

3. 可以将库文件下到本地用UE打开，然后你就找吧。

另外，看动态库用 nm -D lib*.so

附：

1.ar基本用法
2.nm基本用法命令

　当我们的程序中有经常使用的模块，而且这种模块在其他程序中也会用到，这时按照软件重用的思想，我们应该将它们生成库，使得以后编程可以减少开发代码量。这里介绍两个命令ar和nm，用来对库操作。

1.ar基本用法

　　ar命令可以用来创建、修改库，也可以从库中提出单个模块。库是一单独的文件，里面包含了按照特定的结构组织起来的其它的一些文件（称做此库文件的member）。原始文件的内容、模式、时间戳、属主、组等属性都保留在库文件中。

　　下面是ar命令的格式：

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

　　例如我们可以用ar rv libtest.a hello.o hello1.o来生成一个库，库名字是test，链接时可以用-ltest链接。该库中存放了两个模块hello.o和hello1.o。选项前可以有‘-‘字符，也可以没有。下面我们来看看命令的操作选项和任选项。现在我们把{dmpqrtx}部分称为操作选项，而[abcfilNoPsSuvV]部分称为任选项。

　　{dmpqrtx}中的操作选项在命令中只能并且必须使用其中一个，它们的含义如下：

d：从库中删除模块。按模块原来的文件名指定要删除的模块。如果使用了任选项v则列出被删除的每个模块。
m：该操作是在一个库中移动成员。当库中如果有若干模块有相同的符号定义(如函数定义)，则成员的位置顺序很重要。如果没有指定任选项，任何指定的成员将移到库的最后。也可以使用'a'，'b'，或'I'任选项移动到指定的位置。
p：显示库中指定的成员到标准输出。如果指定任选项v，则在输出成员的内容前，将显示成员的名字。如果没有指定成员的名字，所有库中的文件将显示出来。
q：快速追加。增加新模块到库的结尾处。并不检查是否需要替换。'a'，'b'，或'I'任选项对此操作没有影响，模块总是追加的库的结尾处。如果使用了任选项v则列出每个模块。 这时，库的符号表没有更新，可以用'ar s'或ranlib来更新库的符号表索引。
r：在库中插入模块(替换)。当插入的模块名已经在库中存在，则替换同名的模块。如果若干模块中有一个模块在库中不存在，ar显示一个错误消息，并不替换其他同名模块。默认的情况下，新的成员增加在库的结尾处，可以使用其他任选项来改变增加的位置。
t：显示库的模块表清单。一般只显示模块名。
x：从库中提取一个成员。如果不指定要提取的模块，则提取库中所有的模块。
　　下面在看看可与操作选项结合使用的任选项：

a：在库的一个已经存在的成员后面增加一个新的文件。如果使用任选项a，则应该为命令行中membername参数指定一个已经存在的成员名。
b：在库的一个已经存在的成员前面增加一个新的文件。如果使用任选项b，则应该为命令行中membername参数指定一个已经存在的成员名。
c：创建一个库。不管库是否存在，都将创建。
f：在库中截短指定的名字。缺省情况下，文件名的长度是不受限制的，可以使用此参数将文件名截短，以保证与其它系统的兼容。
i：在库的一个已经存在的成员前面增加一个新的文件。如果使用任选项i，则应该为命令行中membername参数指定一个已经存在的成员名(类似任选项b)。
l：暂未使用
N：与count参数一起使用，在库中有多个相同的文件名时指定提取或输出的个数。
o：当提取成员时，保留成员的原始数据。如果不指定该任选项，则提取出的模块的时间将标为提取出的时间。
P：进行文件名匹配时使用全路径名。ar在创建库时不能使用全路径名（这样的库文件不符合POSIX标准），但是有些工具可以。
s：写入一个目标文件索引到库中，或者更新一个存在的目标文件索引。甚至对于没有任何变化的库也作该动作。对一个库做ar s等同于对该库做ranlib。
S：不创建目标文件索引，这在创建较大的库时能加快时间。
u：一般说来，命令ar r...插入所有列出的文件到库中，如果你只想插入列出文件中那些比库中同名文件新的文件，就可以使用该任选项。该任选项只用于r操作选项。
v：该选项用来显示执行操作选项的附加信息。
V：显示ar的版本。
2.nm基本用法命令

　　nm用来列出目标文件的符号清单。下面是nm命令的格式：

　　nm [-a|--debug-syms] [-g|--extern-only] [-B][-C|--demangle] [-D|--dynamic] [-s|--print-armap][-o|--print-file-name] [-n|--numeric-sort][-p|--no-sort] [-r|--reverse-sort] [--size-sort][-u|--undefined-only] [-l|--line-numbers] [--help][--version] [-t radix|--radix=radix][-P|--portability] [-f format|--format=format][--target=bfdname] [objfile...]

　　如果没有为nm命令指出目标文件，则nm假定目标文件是a.out。下面列出该命令的任选项，大部分支持"-"开头的短格式和"—"开头的长格式。

-A、-o或--print-file-name：在找到的各个符号的名字前加上文件名，而不是在此文件的所有符号前只出现文件名一次。
例如nm libtest.a的输出如下：

CPThread.o:
00000068 T Main__8CPThreadPv
00000038 T Start__8CPThread
00000014 T _._8CPThread
00000000 T __8CPThread
00000000 ? __FRAME_BEGIN__
.......................................

则nm -A 的输出如下：

libtest.a:CPThread.o:00000068 T Main__8CPThreadPv
libtest.a:CPThread.o:00000038 T Start__8CPThread
libtest.a:CPThread.o:00000014 T _._8CPThread
libtest.a:CPThread.o:00000000 T __8CPThread
libtest.a:CPThread.o:00000000 ? __FRAME_BEGIN__
..................................................................

-a或--debug-syms：显示调试符号。
-B：等同于--format=bsd，用来兼容MIPS的nm。
-C或--demangle：将低级符号名解码(demangle)成用户级名字。这样可以使得C++函数名具有可读性。
-D或--dynamic：显示动态符号。该任选项仅对于动态目标(例如特定类型的共享库)有意义。
-f format：使用format格式输出。format可以选取bsd、sysv或posix，该选项在GNU的nm中有用。默认为bsd。
-g或--extern-only：仅显示外部符号。
-n、-v或--numeric-sort：按符号对应地址的顺序排序，而非按符号名的字符顺序。
-p或--no-sort：按目标文件中遇到的符号顺序显示，不排序。
-P或--portability：使用POSIX.2标准输出格式代替默认的输出格式。等同于使用任选项-f posix。
-s或--print-armap：当列出库中成员的符号时，包含索引。索引的内容包含：哪些模块包含哪些名字的映射。
-r或--reverse-sort：反转排序的顺序(例如，升序变为降序)。
--size-sort：按大小排列符号顺序。该大小是按照一个符号的值与它下一个符号的值进行计算的。
-t radix或--radix=radix：使用radix进制显示符号值。radix只能为"d"表示十进制、"o"表示八进制或"x"表示十六进制。
--target=bfdname：指定一个目标代码的格式，而非使用系统的默认格式。
-u或--undefined-only：仅显示没有定义的符号(那些外部符号)。
-l或--line-numbers：对每个符号，使用调试信息来试图找到文件名和行号。对于已定义的符号，查找符号地址的行号。对于未定义符号，查找指向符号重定位入口的行号。如果可以找到行号信息，显示在符号信息之后。
-V或--version：显示nm的版本号。
--help：显示nm的任选项。

Linux动态库、静态库加载基础
静态库
       在linux环境中, 使用ar命令创建静态库文件.如下是命令的选项:
          d -----从指定的静态库文件中删除文件
          m -----把文件移动到指定的静态库文件中
          p -----把静态库文件中指定的文件输出到标准输出
          q -----快速地把文件追加到静态库文件中
          r -----把文件插入到静态库文件中
          t -----显示静态库文件中文件的列表
          x -----从静态库文件中提取文件
          还有多个修饰符修改以上基本选项,详细请man ar 以下列出三个:
          a -----把新的目标文件(*.o)添加到静态库文件中现有文件之后
          b -----***************************************之前
          v -----使用详细模式       ar 命令的命令行格式如下:       ar [-]{dmpqrtx}[abcfilNoPsSuvV] [membername] [count] archive files...      eg:         ar -crs hello.a hello.c
动态库
1.创建共享库
     gcc -c error.c               
     gcc -c errorlog.c
     gcc -shared -o libapue.so error.o errorlog.o
这样就创建了共享库!
2.编译共享库
    假设共享库位于当前目录(即跟程序文件相同的目录中)
gcc -o test -L. -lapue test.c
这样就编译出了不包含函数代码可执行文件了,但是但你运行时会发现linux动态加载器打不到libapue.so文件.
可以用ldd 命令查看可执行文件依赖什么共享库:
ldd test
如何才能让动态加载器发现库文件呢?有两种方法可以解决:
     LD_LIBRARY_PATH 环境变量  
     /etc/ld.so.conf文件
    1.环境变量
       export LD_LIBRARY_PATH="dir$LD_LIBRARY_PATH"
    2.修改/etc/ld.so.conf文件.位于/etc/ld.so.conf
一般应用程序的库文件不与系统库文件放在同一个目录下,一般把应用程序的共享库文件放在/usr/local/lib下,新建一个属于自己的目录apue,然后把刚才libapue.so复制过去就行了
同时在/etc/ld.so.conf中新增一行:
/usr/local/lib/apue
实例分析：
    test.c
         #include
         #include "print.h"
         
         int main(void){
             printf("Function : main/n");
             print();
             printf("out main/n");
   
             return 0;
         }
     
     print.c
         #include
         #include
         int print(void){
            
             printf("Function : print/n");
             printf("Hello world/n");
             printf("out print/n");
             return 0;
         }
       1 : 创建动态库：
          gcc -o libprint.so -fPIC -rdynamic -shared print.c
     2 : 创建可执行文件
          gcc -o test -I$(INC_PATH) -L$(LIB_PATH) -lprint test.c
　　３： 如果出现下列错误
      　　　　./test: error while loading shared libraries: libprint.so: cannot open 　　shared object file: No such file or directory
　　　　　　解决方法：
　　　　　　　１：　export LD_LIBRARY_PATH=DIR:$LD_LIBRARY_PATH
　　　　　　　２：　修改文件/etc/ld.so.config文件，在末行加上你的库文件目录，最后,ldconfig刷新ld.so.cache文件即可。可以用strings命令查看ld.so.cache是否刷新：strings /etc/ld.so.cache | grep print
     
４：   ldd命令查看动态连接库
            
            linux-gate.so.1 =>  (0xb7f0e000)
            libprint.so => not found
            libc.so.6 => /lib/tls/i686/cmov/libc.so.6 (0xb7d82000)
            /lib/ld-linux.so.2 (0xb7ef4000)
５ ：　nm查看程序中有那些符号
　　　　　　
049f18 d _DYNAMIC
08049ff4 d _GLOBAL_OFFSET_TABLE_
080485cc R _IO_stdin_used
         w _Jv_RegisterClasses
08049f08 d __CTOR_END__
08049f04 d __CTOR_LIST__
08049f10 D __DTOR_END__
08049f0c d __DTOR_LIST__
080485ec r __FRAME_END__
08049f14 d __JCR_END__
08049f14 d __JCR_LIST__
0804a018 A __bss_start
0804a010 D __data_start
08048580 t __do_global_ctors_aux
08048450 t __do_global_dtors_aux
0804a014 D __dso_handle
         w __gmon_start__
0804857a T __i686.get_pc_thunk.bx
08049f04 d __init_array_end
08049f04 d __init_array_start
08048510 T __libc_csu_fini
08048520 T __libc_csu_init
         U __libc_start_main@@GLIBC_2.0
0804a018 A _edata
0804a020 A _end
080485ac T _fini
080485c8 R _fp_hw
0804839c T _init
08048420 T _start
0804a018 b completed.6625
0804a010 W data_start
0804a01c b dtor_idx.6627
080484b0 t frame_dummy
080484d4 T main
         U print
         U puts@@GLIBC_2.0
６：　strip取出程序中符号
７：　strings查看可执行文件中的文本信息
    　　
参考：http://www.kuqin.com/linux/20081103/25444.html
      http://hi.baidu.com/li_zhongnan/blog/item/1d9bf3c2e13a9f32e4dd3b4f.html

1.       Linux静态库和动态库的命名规则：

静态函数库：静态库的名字一般是libxxx.a，利用静态库编译生成的文件比较大，因为整个静态库所有的数据都会被整合进目标代码中。

a)       优点：编译后，可执行文件不需要外部支持；

b)       缺点：生成的可执行程序大；静态库改变了，就需要重新编译可执行程序。

动态函数库：动态库的名字一般是libxxx.so，相对于静态库，动态函数库在编译的时候并没有被编译进目标代码中，你的程序执行到相关函数时才调用函数库里面相应的函数，因此使用动态函数库生成的可执行文件比较小。由于函数库没有编译进可执行程序，而是程序运行时动态的申请调用，所以程序的运行环境中必须提供相应的库。动态函数库的改变也不会影响可执行程序，针对可执行程序的动态函数库升级也比较容易。

a)       优点：实现进程的资源共享，当程序在运行的时候需要调用某个动态链接库函数时候，OS会先查看所有正在运行的程序，看内存里面是否已经有此函数的拷贝了，有责共享那个拷贝，没有才会链接载入，这样会大大节省OS的内存资源；

b)       优点：升级容易，升级动态链接库即可，不需要重新编译可执行程序；

2.       Gcc/g++的编译链接：

通常，对函数的链接是在编译期的时候完成的，所有相关的对象文件与相关联的library被链接成一个可执行文件，这就是使用静态库的编译过程，

而动态库技术：对一些库函数的链接载入推迟到程序运行的时候。

但是，不管是使用静态库还是使用动态库，这些库文件都是由*.o文件生成的，在给编译器gcc传不同的参数，就会生成相应的静态库或者是动态库了。

3.       静态库和动态库的创建过程：

a)       创建静态库：

在linux环境下，创建静态库是使用ar命令，具体的选项可以man查看下，例子：

ar  -rt libtest.a   error.o  show.o  test.o

这样就创建了libtest.a静态库文件。

b)       创建动态库：

使用gcc编译.c文件的使用，使用-fPIC标签，然后在使用*.o文件生成动态库文件的时候，传递-shared标签给gcc，例子：

Gcc  –fPIC  –c  file1.c

Gcc  -fPIC  -c  file2.c

Gcc  –shared  libtest.so  file1.o  file2.o

这样就创建了libtest.so动态库文件。

4.       使用静态库和动态库的方法：

动态库文件和静态库文件的使用方法基本上差不多，在gcc的command里面使用-Lpath和-lxxx标签：

Gcc file1.o file2.o –Lpath –lxxx –o yourprogrammer

编译器会先到path下面寻找libxxx.so文件，如果没有找到，继续寻找libxxx.a文件。

那么动态库函数文件，是在程序运行的过程中决定是否载入的，那么我们需要告诉编译器，去哪里能找到动态库函数文件，在linux或者类unix操作系统里面是使用LD_LIBRARY_PATH环境变量来实现的。