Linux -- Linux下库的生成和使用

Myth丶恋晨 2022-11-09 12:58 201阅读 0赞

### 内容预览 ###

*  零、读前说明
 *  一、首先来几个简单的直入灵魂的问题
 *  二、库文件？动态库？静态库？区别？
 *  三、如何生成动态库、静态库
 *   *  3.1、静态库的生成
     *  3.2、动态库的生成
 *  四、链接、调用静态库、动态库
 *   *  4.1 静态库的链接与测试
     *  4.2 动态库的链接与测试
     *   *  4.2.1 隐式调用
         *  4.2.2 显示调用
 *  五、结尾

# 零、读前说明 #

*  本文中所有设计的代码均通过测试，并且在功能性方面均实现应有的功能。
 *  如果你也对此感兴趣、也想进一步探讨的话，可以私聊我，非常欢迎一起探讨学习。
 *  由于时间、水平、精力有限，文中难免会出现不准确、甚至错误的地方，也非常欢迎大佬看见的话批评指正。
 *  嘻嘻嘻。。。。 。。。。。。。。收！

在写程序的过程中，基本上都要依赖各种各样的库，比如标准C库等等，使用库也很大程度上减少了重复不必要的编程，也使得编写的程序精简不少。所以，当我们在编程中用到自己开发的使用比较频繁的资源的时候，也希望能够编译成库的模式。在需要用到的时候直接引用即可。那么接下来就简单描述下在 **Linux** 环进行的动态库和静态库的生成和使用。

# 一、首先来几个简单的直入灵魂的问题 #

什么是库文件？
    什么是动态库，共享库？
    什么是静态库？
    动态链接库和静态链接库有什么区别？
    如何生成静态/动态链接库？
    如何链接或者调用静态/动态链接库？
    什么是显式调用和隐式调用？

# 二、库文件？动态库？静态库？区别？ #

1、库文件就是 **资源文件**，库从本质上来说是 **一种可被载入内存中执行的二进制格式文件**。

2、根据 **链接时期** 的不同，库又可以分为 **静态库** 和 **动态库(共享库，以下都将称呼为动态库)**。

3、**静态库**

1）这类库的名字一般都是 **libxxx.a** ；  
    2）静态库的代码在编译过程中已经被载入可执行程序，因此可执行程序体积较大；  
    3）每一个连接了静态库的可执行程序都要一个静态库的副本，内存中重复存在多次；  
    4）可执行程序升级困难，静态库升级后，还需要重新编译可执行程序。

4、**动态库**  
    1）这类库的名字一般是 **libxxx.so** ，或 **libxxx.so.xx** ，其中 **xx** 表示版本；  
    2）动态库的代码在可执行程序运行时才载入内存中，在程序编译过程中仅为简单的引用，因此可执行程序体积较小；  
    3）多个可执行程序可以同时使用一个动态库，所在运行环境中必须提供相应的库；  
    4）可执行程序升级方便，动态库的改变不影响可执行程序。

# 三、如何生成动态库、静态库 #

需要说明的是：

1、无论静态库，还是动态库，都是由 **.o** 文件创建的。

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

我们以下面的代码来进行简单的演示和说明，代码文件如下。

$ tree libraryTest/
    libraryTest
    ├── main.c
    ├── mymath.c
    └── mymath.h
    
    0 directories, 3 files

## 3.1、静态库的生成 ##

对于想要生成静态库，则可以如下按步操作。

1、生成对应的 **.o** 文件

$ gcc -c mymath.c

2、生成对应的静态库

$ ar r libmymath.a mymath.o
      或者
    $ ar cr libmymath.a mymath.o

其中：  
  1）**mymath.c** 为源文件，**mymath.o** 为目标文件，**libmymath.a** 为静态库文件  
  2）静态库名必须以 **lib** 开头，**.a** 结尾  
  3）**ar** 指令的参数必须为 **.o** 文件，所以我们必须将 **.c** 文件编译成 **.o** 文件  
  4）在 UNIX 中，使用 **ar** 命令创建或者操作静态库

ar           archivefile objfile
    
    	archivefile  archivefile是静态库的名称
    
    	objfile      objfile是已.o为扩展名的中间目标文件名，可以多个并列
    
    	参数        意义
    
    	-r         将objfile文件插入静态库尾或者替换静态库中同名文件
    	-x         从静态库文件中抽取文件objfile
    	-t         打印静态库的成员文件列表
    	-d         从静态库中删除文件objfile
    	-s         重置静态库文件索引
    	-v         创建文件冗余信息
    	-c         创建静态库文件

## 3.2、动态库的生成 ##

动态库的生成与静态库的类似，对于想要生成动态库，则可以如下操作。

1、生成对应的 **.o** 文件

$ gcc -c mymath.c

2、生成对应的动态库

$ gcc -shared mymath.o -o  libmymath.so

相对于静态库，动态库直接通过 **GCC** 的选项 **-shared** 生成，所以可以省略生成 **.o** 文件的过程，直接通过 **.c** 文件进行动态库的编译生成。

$ gcc -shared mymath.c -o libmymath.so
        或者
    $ gcc -fPIC -shared mymath.c -o libmymath.so

其中：  
  1）**mymath.c** 为源文件，**mymath.o** 为目标文件，**libmymath.so** 为动态库文件  
  2）动态库明必须要以 **lib** 开头，**.so** 或者 **.so.xx** 结尾，**.xx** 表示为版本号  
  3）**GCC** 的选项 **-shared** 说明生成的是动态链接（共享）库， **-o** 后面为生成动态链接库文件名  
  4）在进行动态库的编译中，重要的是 GCC 命令行的两个选项。

-shared : 指定生成动态连接库, 不是可执行文件
        -fPIC   : 表示编译为位置无关的代码，使用相对地址，因为在动态库被加载是，在内存中位置不是固定的  
    	      不用此选项的话，动态载入时可以理解为copy，而不能达到真正代码段共享的目的

# 四、链接、调用静态库、动态库 #

我们已经生成了动态库和静态库，所以文件结构如下所示。

libraryTest/ 
    ├── libmymath.a
    ├── libmymath.so
    ├── main.c
    ├── mymath.c
    ├── mymath.h
    └── mymath.o
    
    0 directories, 6 file

**注意：**

**1、GCC编译默认优先搜索共享库，共享库不存在的时候再去搜索静态库**  
  **2、为了确保使用的是静态库，编译时可以加上 -static 选项**

各个文件实现的源代码分别如下所示。  
  1、**mymath.c** 文件内容如下。

#include "mymath.h"
    
    int add(int a, int b)
    { 
    	return a + b;
    }
    
    int sub(int a, int b)
    { 
    	return a - b;
    }
    int mul(int a, int b)
    { 
    	return a * b;
    }
    
    int dev(int a, int b)
    { 
    	return a / b;
    }

2、**mymath.h** 文件内容如下。

#ifndef __MYMATH_H__
    #define __MYMATH_H__
    
    int add(int, int);
    int sub(int, int);
    int mul(int, int);
    int dev(int, int);
    
    #endif

3、**main.c** 文件内容如下。

#include "mymath.h"
    #include <stdio.h>
    
    int main(int argc, const char **argv)
    { 
        int a = 10, b = 2;
    
        printf("add(%d, %d) = %d\n", a, b, add(a, b));
        printf("sub(%d, %d) = %d\n", a, b, sub(a, b));
        printf("mul(%d, %d) = %d\n", a, b, mul(a, b));
        printf("dev(%d, %d) = %d\n", a, b, dev(a, b));
    
        return 0;
    }

## 4.1 静态库的链接与测试 ##

**说明**：因为优先动态库的搜索，所以在测试静态库之前，先将动态库修改为其他名字。

$ mv libmymath.so  libmymath.so.bak
    $ ls
    libmymath.so.bak libmymath.a main.c  mymath.c  mymath.h  mymath.o

静态库的链接是在编译时将目标代码加入到可执行程序中，并且因为生成的静态库文件与源码文件在同一个目录下。所以编译时使用：

$ gcc -c main.c -o main.o
    $ gcc main.o -o main -L. -lmymath

或者直接使用下面指令编译：

$ gcc main.c -o main -L. -lmymath

其中：

-L 用于指定当前链接库的路径
    	.  表示在当前目录下

当然，在动态库静态库众多的情况下，确保在没有相应动态库存在时运行正常，在编译的时候加上 **-static** 选项。下面进行一个简单的测试。

/* 首先将动态库的名称修改成与静态库一致 */
    $ mv libmymath.so.bak  libmymath.so
    
    /* 查看当前目录下的文件*/
    $ ls
    libmymath.so libmymath.a main.c  mymath.c  mymath.h  mymath.o
    
    /* 链接静态库编译程序 */
    $ gcc main.c -o main -L. -lmymath -static

如此，则链接静态库的程序就编译完成了，此时如果删去 **libmymath.a** 文件，对程序的执行也不会造成任何影响。

所以，测试的效果截图如下图所示。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poZW1pbmdidWhhbw_size_16_color_FFFFFF_t_70][]图4.1 静态库测试示意图

## 4.2 动态库的链接与测试 ##

不同动态库版本，只要其共享对象接口相同，就可以直接动态加载。

动态库的使用则分为 **显式调用** 和 **隐式调用** 两种方式，主要区别如下：

*  1、显式调用由调用者在需要时自己加载，不再使用时还需要自己负责卸载，而隐式调用由系统加载完成，无需调用者参与
 *  2、显式调用的方式，必须加入头文件 **dlfcn.h**，需要用 **dlopen** 加载库， **dlsym** 取函数符号， **dlclose** 卸载库。
 *  3、显式调用需要在调用时，指明要加载的动态库的名称和要调用的函数名称，而隐式调用则和使用当前项目下的其他函数一样
 *  4、 显式调用需要在链接命令中要加入参数 **-ldl**，隐式调用在链接命令中要加入参数 -l加库名，然后直接用库里的函数名即可
 *  5、隐式调用时，调用者必须要加上动态库中的头文件，编译时可能还需要用参数 **-I** 指明头文件的位置
 *  6、显示调用比较灵活，而隐式调用比较透明

### 4.2.1 隐式调用 ###

所谓隐式调用，就是调用动态库的时候直接使用动态库中的函数。但是在隐式调用的时候必须要让程序能找到调用的函数的所属动态库。有几种方式指定路径：

1. 增加环境变量
    2. 使用参数 LD_LIBRARY_PATH 指定
    3. 使用系统配置文件指定

1、在不修改系统配置文件或者环境变量的情况下，调用动态库编译程序的时候，可以如下所示进行。

$ gcc main.c -o main ./libmymath.so
        或者
    $ gcc main.c -o main -L. -lmymath

**注意**：在没将动态库增加环境变量或者系统配置文件指定的情况下：

a、使用前面的指令编译，当执行程序时，会自动在当前路径下操作动态库 libmymath.so  
   b、但是使用第二条指令编译，那么在执行程序的时候，需要再次指定链接动态库的路径

我们简单看一下测试的效果，截图如下图所示。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poZW1pbmdidWhhbw_size_16_color_FFFFFF_t_70 1][]图4.2 测试效果示意图

2、想要上图最后执行的时候能够正常连接动态库，程序正确执行，那么就需要告知程序动态库的路径或者将动态库增加到环境变量中。所以，要达到目的有以下几种方法：

1）将自己的动态链接库文件拷贝到系统库路径的目录下，那么在运行程序的时候不在进行路径指定，并且在删除前一直有效。

$ sudo cp libmymath.so /usr/local/lib

相对上面的操作方式，比较推荐的是 **创建一个软连接** 的形式，指令如下：

$ sudo ln -s  绝对路径/libmymath.so /usr/lib/libmymath.so

2）将生成的动态链接库文件所在路径加入到 **ld.so.conf** 文件中。ld.so.conf 是系统对动态链接库进行查找的路径配置文件。完成后同样在运行程序的时候不在进行路径指定，并且在删除前一直有效。

/* 打开并编辑 libmymath.conf 文件，没有的话创建并打开  */
    $ sudo vi /etc/ld.so.conf.d/libmymath.conf
    
       然后写动态库的绝对路径，比如 /home/songshuai/test/
    
        或者
    
    /* 将当前路径写入到文件libmymath.conf中，请注意下面这条指令需要在root权限下操作才有效 */
    # pwd >> /etc/ld.so.conf/libmymath.conf
    
    /* 写入完成后，执行 ldconfig 刷新 */
    $ sudo ldconfig

3）把当前路径加入环境变量 LD\_LIBRARY\_PATH，其实就是 /usr/bin/ld 的环境变量，但是需要注意只对当前 bash 有效。

$ export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/home/songshuai/test/

4）如果只是链接测试或进行调试等，那么可以在程序运行时直接指定当前链接动态库的路径，同样需要注意的此种方式只对本次运行有效。

$ LD_LIBRARY_PATH=. ./main
    
    其中：
        LD_LIBRARY_PATH：标识动态连接器可以装载动态库的路径

综上，通过上面的任何一种方式，我们都将可以将动态库正确的连接到程序中，再来一个程序运行的最终效果图。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poZW1pbmdidWhhbw_size_16_color_FFFFFF_t_70 2][]图4.3 测试效果示意图

### 4.2.2 显示调用 ###

所谓显式调用动态库，就是编译时无需库文件，执行时动态可存储于任意位置，但是库里共享对象必须先申请然后使用。

显式调用需要使用以下几个函数：

void *dlopen (const char *filename, int flag);
    说明：
    	打开动态库 
    参数：
    	filename ：动态库路径或者名称，如果名字不以/开头（相对路径），将按下列先后顺序查找该文件
    		1. 用户环境变量中的LD_LIBRARY_PATH值
    		2. 动态链接缓冲文件/etc/ld.so.cache
    		3. 目录/lib、/usr/lib
    	flag     ：可选为下面两个参数，分别表示为：
    		RTLD_LAZY：表明在动态链接库的函数代码执行时解决 
    		RTLD_NOW ：表明在dlopen 返回前就解决所有未定义的符号，一旦未解决，dlopen 将返回错误 
    返回：
    	成功则返回为void*的句柄
    	失败则返回NULL
    
    void *dlsym(void *handle, char *symbol);
    说明：
    	获取动态库对象地址
    参数：
    	handle：动态链接库操作句柄
    	symbol：符号，也就是函数名称
    返回： 
    	成功则返回符号对应的函数的执行代码地址。由此地址，可以带参数执行相应的函数。
    	失败则返回NULL
    int dlclose (void *handle);
    说明：
    	关闭指定句柄的动态库，只有当此动态链接库的使用计数为0时,才会真正被系统卸载
    参数：
    	handle：动态链接库操作句柄
    返回：
    	卸载成功则返回0
    	卸载失败则返回非0值
    const char *dlerror(void);
    说明：
    	错误检测，当动态链接库操作函数执行的结果返回
    返回：
    	函数执行成功 返回 NULL
    	函数执行失败 返回出错信息

下面还是针对上面生成的动态库 **libmymath.so** 进行显式调用的测试代码。

1、测试代码如下所示。

#include <dlfcn.h> //用于动态库管理的系统头文件
    #include <stdio.h>
    
    int main(int argc, char *argv[])
    { 
        //声明对应的函数的函数指针
        int (*pAdd)(int, int);
        int (*pSub)(int, int);
        int (*pMul)(int, int);
        int (*pDev)(int, int);
    
        //加载动态库
        void *pdlHandle = dlopen("/path/libmymath.so", RTLD_LAZY);
        //错误处理
        if (pdlHandle == NULL)
        { 
            printf("Failed load library\n");
            return -1;
        }
    
        // 判断是否发生异常
        char *pszErr = dlerror();
        if (pszErr != NULL)
        { 
            printf("%s\n", pszErr);
            return -1;
        }
    
        //获取函数的地址
        pAdd = dlsym(pdlHandle, "add");
        // 判断是否发生异常
        pszErr = dlerror();
        if (pszErr != NULL)
        { 
            printf("%s\n", pszErr);
            dlclose(pdlHandle); // 关闭动态库连接
            return -1;
        }
        // 下面也是获取对应函数的地址，为了方便所在就不再进行异常判断
        pSub = dlsym(pdlHandle, "sub");
        pMul = dlsym(pdlHandle, "mul");
        pDev = dlsym(pdlHandle, "dev");
    
        //实现函数调用
        printf("(*pAdd)(10, 2) = %d\n", (*pAdd)(10, 2));
        printf("(*pSub)(10, 2) = %d\n", (*pSub)(10, 2));
        printf("(*pMul)(10, 2) = %d\n", (*pMul)(10, 2));
        printf("(*pDev)(10, 2) = %d\n", (*pDev)(10, 2));
    
        //程序结束时关闭动态库
        dlclose(pdlHandle);
    
        return 0;
    }

2、编译测试文件，需要使用 **-ldl** 选项指定生成的对象模块需要使用的共享库。

$ gcc main.c -o main -ldl

3、执行测试程序，测试效果如下图所示。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poZW1pbmdidWhhbw_size_16_color_FFFFFF_t_70 3][]图4.4 测试效果示意图

# 五、结尾 #

好啦，废话不多说，总结写作不易，如果你喜欢这篇文章或者对你有用，请动动你发财的小手手帮忙**点个赞**，当然**关注一波**那就更好了，就到这儿了，么么哒(\* ￣3)(ε￣ \*)。

![20201117155233402.gif][]

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poZW1pbmdidWhhbw_size_16_color_FFFFFF_t_70]: /images/20221023/acaadec8cde84f0cbf9081914b243cd9.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poZW1pbmdidWhhbw_size_16_color_FFFFFF_t_70 1]: /images/20221023/80fd56b483cf4f179fa1c1c81c31249c.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poZW1pbmdidWhhbw_size_16_color_FFFFFF_t_70 2]: /images/20221023/d71a89806bc2400d9c6467e96578516b.png
[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L3poZW1pbmdidWhhbw_size_16_color_FFFFFF_t_70 3]: /images/20221023/4c7738d30e68433a9b5b904ca4f7c640.png
[20201117155233402.gif]: /images/20221023/8ea74d5a10874387a18de1dd694e4846.png