Linux中.a,.la,.o,.so文件的意义和编程实现

Linux中.a,.la,.o,.so文件的意义和编程实现
    Linux下文件的类型是不依赖于其后缀名的，但一般来讲：
        .o,是目标文件,相当于windows中的.obj文件
        .so 为共享库,是shared object,用于动态连接的,和dll差不多
        .a为静态库,是好多个.o合在一起,用于静态连接
        .la为libtool自动生成的一些共享库，vi编辑查看，主要记录了一些配置信息。可以用如下命令查看*.la文件的格式   $file *.la

*.la: ASCII English text
        所以可以用vi来查看其内容。
        ＠＠＠＠＠＠＠＠＠＠＠＠＠＠＠＠＠＠＠＠＠＠＠＠＠＠＠＠＠＠＠＠＠＠＠＠
        创建.a库文件和.o库文件：
        [yufei@localhost perl_c2]$ pwd
        /home/yufei/perl_c2

[yufei@localhost perl_c2]$ cat mylib.c
        #include <stdio.h>
        #include <string.h>
        void hello(){
                printf("success call from perl to c library\n");
        }
        [yufei@localhost perl_c2]$ cat mylib.h
        extern void hello();

[yufei@localhost perl_c2]$ gcc -c mylib.c
        [yufei@localhost perl_c2]$ dir
        mylib.c  mylib.h  mylib.o
        [yufei@localhost perl_c2]$ ar -r mylib.a mylib.o
        ar: 正在创建 mylib.a
        [yufei@localhost perl_c2]$ dir
        mylib.a  mylib.c  mylib.h  mylib.o

easyeclipse环境下生成.so文件吧
1.选择新建工程，建立一个c++工程
2.在工程类型选项里选择 Shared Library，然后填入工程名字PXXX点击完成即可。
3.编写程序，然后编译就会在debug或者release里生成一个libPXXX.so文件，如果不要lib的起头标记点击project菜单的Properties选项，然后在弹出的界面的右边点击Build artifact页面，将Output prefix选项的内容清空即可。

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

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

so_test.h：
        #include <stdio.h>
        #include <stdlib.h>
        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_c.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，那么应该是连接正常了，此时找不到libtest.so,mv此库到/usr/lib后正常，也可以使用export LD_LIBRARY_PATH:
    [op@TIM test]$ LD_LIBRARY_PATH=$(pwd)
    [op@TIM test]$ export LD_LIBRARY_PATH

$ ldd test＃查看依赖哪些库
        执行test，可以看到它是如何调用动态库中的函数的。

3、编译参数解析
        最主要的是GCC命令行的一个选项:
        -shared 指明生成动态连接库（让连接器生成T类型的导出符号表，有时候也生成弱连接W类型的导出符号），不用该标志外部程序无法连接。相当于一个可执行文件
        -fPIC：表示编译为位置独立的代码，不用此选项的话编译后的代码是位置相关的，所以动态载入时是通过代码拷贝的方式来满足不同进程的需要，而不能达到真正代码段共享的目的。
        -L.：表示要连接的库在当前目录中
        -ltest：编译器查找动态连接库时有隐含的命名规则，即在给出的名字前面加上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文件来指定动态库的目录。通常这样做就可以解决库无法链接的问题了。
        makefile里面怎么正确的编译和连接生成.so库文件，然后又是在其他程序的makefile里面如何编译和连接才能调用这个库文件的函数????
        答:你需要告诉动态链接器、加载器ld.so在哪里才能找到这个共享库,可以设置环境变量把库的路径添加到库目录/lib和/usr/lib，LD_LIBRARY_PATH=$(pwd),这种方法采用命令行方法不太方便,一种替代方法
        ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^注释^^^^^^^^^^^^^^^^^^^^^^^^^^^^
        LD_LIBRARY_PATH可以在/etc/profile还是 ~/.profile还是 ./bash_profile里设置，或者.bashrc里，

改完后运行source /etc/profile或 . /etc/profile
        更好的办法是添入/etc/ld.so.conf, 然后执行 /sbin/ldconfig

^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^注释^^^^^^^^^^^^^^^^^^^^^^^^^^^^
        是把库路径添加到/etc/ld.so.conf，然后以root身份运行ldconfig
        也可以在连接的时候指定文件路径和名称 -I  -L.

GCC=gcc
        CFLAGS=-Wall -ggdb -fPIC
        #CFLAGS=
        all: libfunc test
        libfunc:func.o func1.o
                $(GCC) -shared -Wl,-soname,libfunc.so.1 -o libfunc.so.1.1 $<
                ln -sf libfunc.so.1.1 libfunc.so.1
                ln -sf libfunc.so.1 libfunc.so
        ***********************************************注释************************************************
        ln -s是用来创建软链接，也就相当于windows中的快捷方式，在当前目录中创建上一级目录中的文件ttt的命名为ttt2软链接的命令是ln -s ../ttt ttt2,如果原文件也就是ttt文件删除的话，ttt2也变成了空文件。
        ln -d是用来创建硬链接，也就相当于windows中文件的副本，当原文件删除的时候，并不影响“副本”的内容。

编译目标文件时使用gcc的-fPIC选项，产生与位置无关的代码并能被加载到任何地址：
        gcc –fPIC –g –c liberr.c –o liberr.o
        使用gcc的-shared和-soname选项；
        使用gcc的-Wl选项把参数传递给连接器ld；
        使用gcc的-l选项显示的连接C库，以保证可以得到所需的启动（startup）代码，从而避免程序在使用不同的，可能不兼容版本的C库的系统上不能启动执行。
        gcc –g –shared –Wl,-soname,liberr.so –o liberr.so.1.0.0 liberr.o –lc

建立相应的符号连接：
        ln –s liberr.so.1.0.0 liberr.so.1;
        ln –s liberr.so.1.0.0 liberr.so;

在MAKEFILE中：
        $@
            表示规则中的目标文件集。在模式规则中，如果有多个目标，那么，"$@"就是匹配于目标中模式定义的集合。
        $%
           仅当目标是函数库文件中，表示规则中的目标成员名。例如，如果一个目标是"foo.a(bar.o)"，那么，"$%"就是"bar.o"，"$@"就是"foo.a"。如果目标不是函数库文件（Unix下是[.a]，Windows下是[.lib]），那么，其值为空。
        $<
            依赖目标中的第一个目标名字。如果依赖目标是以模式（即"%"）定义的，那么"$<"将是符合模式的一系列的文件集。注意，其是一个一个取出来的。
        $?
            所有比目标新的依赖目标的集合。以空格分隔。
        $^
            所有的依赖目标的集合。以空格分隔。如果在依赖目标中有多个重复的，那个这个变量会去除重复的依赖目标，只保留一份。
        *********************************************注释***********************************************************************
        test: test.o libfunc
                $(GCC) -o test test.o -L. -lfunc
        %.o:%.c
                $(GCC) -c $(CFLAGS) -o $@ $<
        clean:
                rm -fr *.o
                rm -fr *.so*
                rm -fr test

要生成.so文件，cc要带-shared 参数；要调用.so的文件，比如libfunc.so,可以在cc命令最后加上-lfunc，还要视情况加上-L/usr/xxx 指出libfunc.so的路径；这样，在你要编译的源文件中就可以调用libfunc.so这个库文件的函数.
               前面的都说的差不多了，最后提醒一下最好提供一个接口头文件
               动态加载,用dlopen,dlclose,dlsym

二、静态库
1.编译.c成静态库：
gcc -c test.c
2.由.o文件创建静态库：
ar cr libtest.a test.o
3.在程序中使用静态库（和动态相同）：
gcc test.c -L. -ltest -o test
4.运行：
./test

当Linux静态库和Linux动态库同名时， gcc命令将优先使用动态库。

ar参数
参数r：在库中插入模块(替换)。当插入的模块名已经在库中存在，则替换同名的模块。如果若干模块中有一个模块在库中不存在，ar显示一个错误消息，并不替换其他同名模块。默认的情况下，新的成员增加在库的结尾处，可以使用其他任选项来改变增加的位置。【1】
参数c：创建一个库。不管库是否存在，都将创建。
参数s：创建目标文件索引，这在创建较大的库时能加快时间。（补充：如果不需要创建索引，可改成大写S参数；如果.a文件缺少索引，可以使用ranlib命令添加）

＃显示库文件中有哪些目标文件，只显示名称。
[op@TIM test]$ ar t libtest.a
test.o

＃显示库文件中有哪些目标文件，显示文件名、时间、大小等详细信息。
[op@TIM test]$ ar tv libtest.a
rw-rw-r-- 500/500   1504 Jun 10 17:32 2015 test.o

＃显示库文件中的索引表。
[op@TIM test]$ nm -s libtest.a
Archive index:
main in test.o
test.o:
0000000000000000 T main
                 U test_a
                 U test_b
                 U test_c

＃为库文件创建索引表。
ranlib libtest.a

在shell脚本中使用.a
    OS=`uname -r`  
    ar rcs libhycu.a.$OS *.o

Makefile代码.a
    $(BIN1): $(BIN1_OBJS)  
            ar rcs $@ $^

三、静态库，动态库区别：
静态库是指编译连接时，把库文件的代码全部加入到可执行文件中，所以生成的文件较大，但运行时，就不再需要库文件了。即，程序与静态库编译链接后，即使删除静态库文件，程序也可正常执行。

动态库正好相反，在编译链接时，没有把库文件的代码加入到可执行文件中，所以生成的文件较小，但运行时，仍需要加载库文件。即，程序只在执行启动时才加载动态库，如果删除动态库文件，程序将会因为无法读取动态库而产生异常。

静态函数库（对应.a文件）、共享函数库（对应.so文件，类似于Windows的dll文件）、动态加载函数库（对应.o文件，相当于Windows里的.obj文件）

静态函数库
特点：实际上是简单的普通目标文件的集合，在程序执行前就加入到目标程序中。
优点：可以用以前某些程序兼容；描述简单；允许程序员把程序link起来而不用重新编译代码，节省了重新编译代码的时间（该优势目前已不明显）；开发者可以对源代码保密；理论上使用ELF格式的静态库函数生成的代码可以比使用共享或动态函数库的程序运行速度快（大概1%-5%）
生成：使用ar程序（archiver的缩写）。ar rcs my_lib.a f1.o f2.o是把目标代码f1.o和f2.o加入到my_lib.a这个函数库文件中（如果my_lib.a不存在则创建）
使用：用gcc生成可执行代码时，使用-l参数指定要加入的库函数。也可以用ld命令的-l和-L参数。

共享函数库
    共享函数库在可执行程序启动的时候加载，所有程序重新运行时都可自动加载共享函数库中的函数。.so文件感觉很复杂，光是命名规则就已经看得我很晕了~整理一下，共享库需要：soname、real name，另外编译的时候名字也有说法。依次解释下：
soname：必须的格式：lib+函数库名+.so+版本号信息（但是记住，非常底层的C库函数都不是以lib开头命名的）。例子：/usr/lib/libreadline.so.3
real name：顾名思义是真正的名字啦，有主版本号和发行版本号。但是没找到实例……
编译器编译的时候需要的函数库的名字就是不包含版本号信息的soname，例如上面的例子把最后的.3去掉就可以了。
位置：共享函数库文件必须放在特定目录，对于开放源码来说，GNU标准建议所有的函数库文件都放在/usr/local/lib目录下，而且建议命令、可执行程序都放在/usr/local/bin目录下。不过这个只是习惯啦，可以改变，具体的位置信息可以看/etc/ld.so.conf里面的配置信息。当然，也可以修改这个文件，加入自己的一些特殊的路径要求。
创建：在网上找到了gcc方式和easyeclipse环境下两种创建方式。

gcc方式：
    首先创建object文件，这个文件将加入通过gcc –fPIC 参数命令加入到共享函数库里面，标准格式：gcc -shared -Wl,-soname,your_soname -o library_name file_list library_list（说实话这个标准格式看起来好复杂，我找了个实例，但是好像和那个标准格式稍有不同：gcc test_a.c test_b.c test_c.c -fPIC -shared -o libtest.so）
在easyeclipse环境下生成.so文件：
        1.选择新建工程，建立一个c++工程
        2.在工程类型选项里选择 Shared Library，然后填入工程名字PXXX点击完成即可。
        3.编写程序，然后编译就会在debug或者release里生成一个libPXXX.so文件，如果不要lib的起头标记点击project菜单的Properties选项，然后在弹出的界面的右边点击Build artifact页面，将Output prefix选项的内容清空即可。
        4.如果是C++程序，注意在接口函数的前面加上extern "C"标记，在头文件加上如下标记：
#ifdef   __cplusplus  
#extern   "C"{  
#endif  
头文件主体  
#ifdef　__cplusplus  
}  
#endif  
     如果不加以上标记，经过编译后，so里的函数名并非你编写程序时设定的函数名，在开发环境左侧的工程文件列表中点开debug项里的PXXX.o可以看到so文件里的函数名都是在你设定的函数名后面加了一个__Fi标记，比如你用的设定的函数名称是Func(), 而so里的函数名则为Func__Fi()或者其他的名称。

安装：拷贝共享库文件到指定的标准的目录，然后运行ldconfig。如果没有权限这样做，那么就只好通过修改环境变量来实现这些函数库的使用了。方法不再说了，很复杂。

查看：可以通过运行ldd来看某个程序使用的共享函数库。例如ldd /bin/ls。查看.so文件使用nm命令，如nm libXXX.so。（注意，nm对于静态的函数库和共享的函数库都起作用）

关于覆盖：如果想用自己的函数覆盖某个库中的一些函数，同时保留该库中其他的函数的话，可以在/etc/ld.so.preload中加入要替换的库（.o结尾的文件），这些preloading的库函数将有优先加载的权利。

关于更新：每次新增加动态加载的函数库、删除某个函数库或者修改某个函数库的路径时，都要重新运行ldconfig来更新/etc/ld.so.cache

四、动态加载的函数库Dynamically Loaded (DL) Libraries
动态加载的函数库Dynamically loaded (DL) libraries是一类函数库，它可以在程序运行过程中的任何时间加载。它们特别适合在函数中加载一些模块和plugin扩展模块的场合，因为它可以在当程序需要某个plugin模块时才动态的加载。例如，Pluggable Authentication Modules(PAM)系统就是用动态加载函数库来使得管理员可以配置和重新配置身份验证信息。

Linux系统下，DL函数库与其他函数库在格式上没有特殊的区别，我们前面提到过，它们创建的时候是标准的object格式。主要的区别就是这些函数库不是在程序链接的时候或者启动的时候加载，而是通过一个API来打开一个函数库，寻找符号表，处理错误和关闭函数库。通常C语言环境下，需要包含这个头文件。
        Linux中使用的函数和Solaris中一样，都是dlpoen（） API。当然不是所有的平台都使用同样的接口，例如HP-UX使用shl_load()机制，而Windows平台用另外的其他的调用接口。如果你的目的是使得你的代码有很强的移植性，你应该使用一些wrapping函数库，这样的wrapping函数库隐藏不同的平台的接口区别。一种方法是使用glibc函数库中的对动态加载模块的支持，它使用一些潜在的动态加载函数库界面使得它们可以夸平台使用。具体可以参考http://developer.gnome.org/doc/API/glib/glib-dynamic-loading-of-modules.html. 另外一个方法是使用libltdl，是GNU libtool的一部分，可以进一步参考CORBA相关资料。

4.1. dlopen()
dlopen函数打开一个函数库然后为后面的使用做准备。C语言原形是：

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

如果文件名filename是以“/”开头，也就是使用绝对路径，那么dlopne就直接使用它，而不去查找某些环境变量或者系统设置的函数库所在的目录了。否则dlopen（）就会按照下面的次序查找函数库文件：
       1. 环境变量LD_LIBRARY指明的路径。

2. /etc/ld.so.cache中的函数库列表。

3. /lib目录，然后/usr/lib。不过一些很老的a.out的loader则是采用相反的次序，也就是先查 /usr/lib，然后是/lib。
    dlopen()函数中，参数flag的值必须是RTLD_LAZY或者RTLD_NOW，RTLD_LAZY的意思是resolve undefined symbols as code from the dynamic library is executed，而RTLD_NOW的含义是resolve all undefined symbols before dlopen() returns and fail if this cannot be done'。
    如果有好几个函数库，它们之间有一些依赖关系的话，例如X依赖Y，那么你就要先加载那些被依赖的函数。例如先加载Y，然后加载X。

dlopen（）函数的返回值是一个句柄，然后后面的函数就通过使用这个句柄来做进一步的操作。如果打开失败dlopen()就返回一个NULL。如果一个函数库被多次打开，它会返回同样的句柄。
    如果一个函数库里面有一个输出的函数名字为_init,那么_init就会在dlopen（）这个函数返回前被执行。我们可以利用这个函数在我的函数库里面做一些初始化的工作。我们后面会继续讨论这个问题的。

4.2. dlerror()
通过调用dlerror()函数，我们可以获得最后一次调用dlopen()，dlsym()，或者dlclose（）的错误信息。

4.3. dlsym()
如果你加载了一个DL函数库而不去使用当然是不可能的了，使用一个DL函数库的最主要的一个函数就是dlsym()，这个函数在一个已经打开的函数库里面查找给定的符号。这个函数如下定义：
        void * dlsym(void *handle, char *symbol);
函数中的参数handle就是由dlopen打开后返回的句柄，symbol是一个以NIL结尾的字符串。如果dlsym()函数没有找到需要查找的symbol，则返回NULL。如果你知道某个symbol的值不可能是NULL或者0，那么就很好，你就可以根据这个返回结果判断查找的symbol是否存在了；不过，如果某个symbol的值就是NULL，那么这个判断就有问题了。标准的判断方法是先调用dlerror()，清除以前可能存在的错误，然后调用dlsym（）来访问一个symbol，然后再调用dlerror（）来判断是否出现了错误。一个典型的过程如下：
[cpp] view plaincopyprint?

dlerror();      /*clear error code */  
    s = (actual_type)dlsym(handle, symbol_being_searched_for);  
    if((error = dlerror()) != NULL){  
        /* handle error, the symbol wasn't found */  
    } else {  
        /* symbol found, its value is in s */  
    }

4.4. dlclose()
dlopen()函数的反过程就是dlclose（）函数，dlclose（）函数用力关闭一个DL函数库。Dl函数库维持一个资源利用的计数器，当调用dlclose的时候，就把这个计数器的计数减一，如果计数器为0，则真正的释放掉。真正释放的时候，如果函数库里面有_fini()这个函数，则自动调用_fini（）这个函数，做一些必要的处理。Dlclose（）返回0表示成功，其他非0值表示错误。

4.5. DL Library Example
下面是一个例子。例子中调入math函数库，然后打印2.0的余弦函数值。例子中每次都检查是否出错。应该是个不错的范例：
#include<stdio.h>
#include<string.h>
#include<dlfcn.h>
int main(int argc,char* argv){
        void* handle;
        char* error;

double(*cosine)(double);
        handle=dlopen("/lib/libm.so.6",RTLD_LAZY);
        if(!handle){
                fputs(dlerror(),stderr);
        }

cosine=dlsym(handle,"cos");
        if((error=dlerror())!=NULL){
                fputs(error,stderr);
        }

printf("%f",(*cosine)(2));
        dlclose(handle);
        return 0;
}

如果这个程序名字叫foo.c,那么用下面的命令来编译：

gcc -o foo foo.c –ldl

五、windows下的dll文件和linux下的.so文件
在开发上来说，是有一点区别的。  
  .so文件没有入口函数的概念。而dll却有，虽然不是必须。  
  .so会导出所有在头文件中定义的符号。而dll却需要使用特殊关键字指名应该导出那些。  
  .so文件是elf格式的，可以不连接某些静态库，而等应用程序去连接。而dll需要连接静态库。

动态链接，在可执行文件装载时或运行时，由操作系统的装载程序加载库。大多数操作系统将解析外部引用（比如库）作为加载过程的一部分。在这些系统上，可执 行文件包含一个叫做import   directory的表，该表的每一项包含一个库的名字。根据表中记录的名字，装载程序在硬盘上搜索需要的库，然后将其加载到内存中预先不确定的位置，之 后根据加载库后确定的库的地址更新可执行程序。可执行程序根据更新后的库信息调用库中的函数或引用库中的数据。这种类型的动态加载成为装载时加载   ，被包括Windows和Linux的大多数系统采用。装载程序在加载应用软件时要完成的最复杂的工作之一就是加载时链接。  
   
  其他操作系统可能在运行时解析引用。在这些系统上，可执行程序调用操作系统API，将库的名字，函数在库中的编号和函数参数一同传递。操作系统负责立即解 析然后代表应用调用合适的函数。这种动态链接叫做运行时链接   。因为每个调用都会有系统开销，运行时链接要慢得多，对应用的性能有负面影响。现代操作系统已经很少使用运行时链接。  
   
  可以动态链接的库，在Windows上是dynamic   link   library   (DLL)，在UNIX或Linux上是Shared   Library。库文件是预先编译链接好的可执行文件，存储在计算机的硬盘上。大多数情况下，同一时间多个应用可以使用一个库的同一份拷贝，操作系统不需 要加载这个库的多个实例。  
   
  Windows   和   Linux   的加载时链接是由操作系统来完成的，格式在不同的系统下有不同的区别，但是原理还是一样的，LZ不必在这个问题上深究。