• 动静态库的使用与制作

    目录

    动静态库的使用与制作

    制作静态库

    使用静态库

    制作动态库

    使用动态库

    动静态库的使用与制作

    • 库文件的命名一般都是 lib开头，然后加库名，然后加 .a/.so

    • 如果是静态库那么就是 .a ，如果是动态库，那么就是 .so

    制作静态库

    下面，我们先试着做一下静态库：

    1. 首先，我们再创建一个 /user/lib 的目录文件。

    2. 再改目录文件里面写一批接口，其中包括 .h 文件和实现 .c 文件。

    myPrint

    1. // myprint.h
    2. #include
    3. #include
    4. ​
    5. ​
    6. extern void Print(const char* str);
    7. // myprint.c
    8. #include"myprint.h"
    9. ​
    10. void Print(const char* str)
    11. {
    12.   printf("%s: [%ld]\n", str, time(NULL));
    13. }

    myMath

    1. // mymath.h
    2. #include
    3. ​
    4. extern int sum(int from, int to);
    5. // mymath.c
    6. #include"mymath.h"
    7. ​
    8. int sum(int from, int to)
    9. {
    10.   int count = 0;
    11.   for(int i = from; i <= to; ++i)
    12.   {
    13.     count += i;
    14.   }
    15.   return count;
    16. }

    1. 之前我们说了，当我们编译文件的时候，只需要将源文件编译为 .o 文件就好了。

    2. 也就是将 mymath.c 和 myprint.c 编译为 .o 文件。（gcc -c ....） 就是编译为 .o 文件。

    1. [lxy@hecs-165234 mklib]$ gcc -c mymath.c -o mymath.o -std=c99
    2. [lxy@hecs-165234 mklib]$ gcc -c myprint.c -o myprint.o -std=c99
    3. [lxy@hecs-165234 mklib]$ ll
    4. total 24
    5. -rw-rw-r-- 1 lxy lxy  141 Oct 12 12:53 mymath.c
    6. -rw-rw-r-- 1 lxy lxy   53 Oct 12 12:43 mymath.h
    7. -rw-rw-r-- 1 lxy lxy 1264 Oct 12 12:54 mymath.o
    8. -rw-rw-r-- 1 lxy lxy   95 Oct 12 12:54 myprint.c
    9. -rw-rw-r-- 1 lxy lxy   73 Oct 12 12:43 myprint.h
    10. -rw-rw-r-- 1 lxy lxy 1584 Oct 12 12:54 myprint.o

    1. 下面，我们写一个自己的源文件，调用这里的函数，我们现在只把.h 和 .o 给别人，那么别人可以使用吗？

    1. // main.c
    2. #include"mymath.h"
    3. #include"myprint.h"
    4. ​
    5. ​
    6. int main()
    7. {
    8.   int res = sum(10,20);
    9.   printf("sum: %d\n", res);
    10. ​
    11.   Print("hello world");
    12.   return 0;
    13. }
    1. [lxy@hecs-165234 uselib]$ ll
    2. total 20
    3. -rw-rw-r-- 1 lxy lxy  145 Oct 12 13:00 main.c
    4. -rw-rw-r-- 1 lxy lxy   53 Oct 12 13:02 mymath.h
    5. -rw-rw-r-- 1 lxy lxy 1264 Oct 12 13:00 mymath.o
    6. -rw-rw-r-- 1 lxy lxy   73 Oct 12 13:02 myprint.h
    7. -rw-rw-r-- 1 lxy lxy 1584 Oct 12 13:00 myprint.o

    1. 下面我们将 main.c 编译为 .o 文件，然后和 其他的 .o 文件编译到一起，可以使用吗？

    1. [lxy@hecs-165234 uselib]$ gcc -c main.c -o main.o
    2. [lxy@hecs-165234 uselib]$ gcc -o my.exe main.o mymath.o myprint.o -std=c99
    3. [lxy@hecs-165234 uselib]$ ll
    4. total 36
    5. -rw-rw-r-- 1 lxy lxy  145 Oct 12 13:00 main.c
    6. -rw-rw-r-- 1 lxy lxy 1680 Oct 12 13:03 main.o
    7. -rwxrwxr-x 1 lxy lxy 8536 Oct 12 13:03 my.exe
    8. -rw-rw-r-- 1 lxy lxy   53 Oct 12 13:02 mymath.h
    9. -rw-rw-r-- 1 lxy lxy 1264 Oct 12 13:00 mymath.o
    10. -rw-rw-r-- 1 lxy lxy   73 Oct 12 13:02 myprint.h
    11. -rw-rw-r-- 1 lxy lxy 1584 Oct 12 13:00 myprint.o

    1. 下面我们运行一下 my.exe 文件，试一下可不可行。

    1. [lxy@hecs-165234 uselib]$ ./my.exe 
    2. sum: 165
    3. hello world: [1697087058]

    1. 是可以的，所以这样子是一种使用别人库的方法。

    2. 但是如果我们这样使用的话，如果有很多 .o 文件，那么是很容易丢弃的，所以其实这样并不好使用。

    3. 那么我们实际上可以将所有的 .o 文件都打包，而这个打包也就叫形成库文件。

    ar -rc lib + 库名 + .a file.o ...

    • 这里的 ar 就是命令 表示的就是 archive(存档/归档)

    • 这里的 r 表示 replace

    • 这里的 c 表示 create

    • 库的名字是 lib 然后加上库名 再加上 .a 而这个名字是随意的。

    • 后面再加上想要归档的 .o 文件。

    1. [lxy@hecs-165234 uselib]$  ar -rc libhello.a mymath.o myprint.o
    2. [lxy@hecs-165234 uselib]$ ll
    3. total 40
    4. -rw-rw-r-- 1 lxy lxy 3058 Oct 12 13:12 libhello.a
    5. -rw-rw-r-- 1 lxy lxy  145 Oct 12 13:00 main.c
    6. -rw-rw-r-- 1 lxy lxy 1680 Oct 12 13:03 main.o
    7. -rwxrwxr-x 1 lxy lxy 8536 Oct 12 13:03 my.exe
    8. -rw-rw-r-- 1 lxy lxy   53 Oct 12 13:02 mymath.h
    9. -rw-rw-r-- 1 lxy lxy 1264 Oct 12 13:00 mymath.o
    10. -rw-rw-r-- 1 lxy lxy   73 Oct 12 13:02 myprint.h
    11. -rw-rw-r-- 1 lxy lxy 1584 Oct 12 13:00 myprint.o

    1. 下面，我们可以将该过程写成自动化的 makefile

    1. libhello.a:mymath.o myprint.o
    2.         ar -rc libhello.a mymath.o myprint.o
    3. mymath.o:mymath.c
    4.         gcc -c mymath.c -o mymath.o -std=c99
    5. myprint.o:myprint.c
    6.         gcc -c myprint.c -o myprint.o
    7. .PHONY:clean
    8. clean:
    9.         rm -rf libhello.a mymath.o myprint.o

    • 首先我们想要形成库文件，这里的库文件是 libhello.a 文件，而依赖方法就是 ar 归档。

    • 该文件依赖于两个 .o 文件。

    • 但是 .o 文件又依赖于 .c 文件。

    • 这里的 mymath.o 依赖于 mymath.c，myprint.o 依赖于 myprint.c，而依赖方法就是 gcc -c 形成 .o 文件。

    1. 下面既然库有了，那么就可以考虑如何发布了。

    2. 一般情况下，我们发布一个库，我们的一个文件里面，有一个 include 文件，该文件里面包含的就是库的头文件，还有一个 lib 文件，该文件里面就是库文件。

    3. 所以下面我们就可以创建一个 hello 的库，该目录里面有一个 include 和 lib 目录，这两个目录中一个是 .h 文件，一个是 .a 文件。

    1. // 继续使用自动化工具
    2. libhello.a:mymath.o myprint.o
    3.         ar -rc libhello.a mymath.o myprint.o
    4. mymath.o:mymath.c
    5.         gcc -c mymath.c -o mymath.o -std=c99
    6. myprint.o:myprint.c
    7.         gcc -c myprint.c -o myprint.o
    8. .PHONY:hello 
    9. hello:
    10.         mkdir -p hello/include
    11.         mkdir -p hello/lib 
    12.         cp *.h hello/include
    13.         cp *.a hello/lib
    14. ​
    15. .PHONY:clean
    16. clean:
    17.         rm -rf libhello.a mymath.o myprint.o hello

    1. 下面我们可以使用一下这个库。

    2. 我们将该库拷贝到，想要使用这个库的目录下。

    1. [lxy@hecs-165234 uselib]$ ll
    2. total 8
    3. drwxrwxr-x 4 lxy lxy 4096 Oct 12 22:24 hello
    4. -rw-rw-r-- 1 lxy lxy  145 Oct 12 13:00 main.c

    使用静态库

    下面开始我们会说三种使用方法：

    第一种

    1. 将 hello 的 include 的内容拷贝到系统的 /usr/include 目录下

    2. 将 hello 的 lib 的内容拷贝到系统的 /lib64 or /usr/lib64 目录下

    1. [lxy@hecs-165234 uselib]$ sudo cp hello/include/* /usr/include/
    2. [sudo] password for lxy: 
    3. [lxy@hecs-165234 uselib]$ ls /usr/include/myprint.h 
    4. /usr/include/myprint.h
    5. [lxy@hecs-165234 uselib]$ ls /usr/include/mymath.h 
    6. /usr/include/mymath.h
    7. [lxy@hecs-165234 uselib]$ sudo cp hello/lib/* /lib64 
    8. [lxy@hecs-165234 uselib]$ ls /lib64/libhello.a 
    9. /lib64/libhello.a

    下面我们编译一下：

    1. [lxy@hecs-165234 uselib]$ gcc -o my.exe main.c
    2. /tmp/ccps443p.o: In function `main':
    3. main.c:(.text+0x13): undefined reference to `sum'
    4. main.c:(.text+0x34): undefined reference to `Print'
    5. collect2: error: ld returned 1 exit status

    为什么报错了？

    实际上，我们自己写的库，或者别人给的库，那么都是属于第三方库的，所以gcc/g++并不认识我们的库，而他们自己的库，gcc/g++是认识的，所以我们需要指明库才可以：

    下面指明库，我们需要带 -l 选项，后面就是我们库的名字，但是库名是去掉 lib 再去掉 .a 就是库名：

    1. [lxy@hecs-165234 uselib]$ gcc main.c -lhello
    2. [lxy@hecs-165234 uselib]$ ll
    3. total 20
    4. -rwxrwxr-x 1 lxy lxy 8536 Oct 12 22:39 a.out
    5. drwxrwxr-x 4 lxy lxy 4096 Oct 12 22:24 hello
    6. -rw-rw-r-- 1 lxy lxy  145 Oct 12 22:34 main.c
    7. [lxy@hecs-165234 uselib]$ ./a.out 
    8. sum: 165
    9. hello world [1697121602]

    我们上面所做的，将头文件于库文件拷贝到系统目录下，就是所谓的“安装”。

    第二种

    就是直接使用：

    1. 我们直接编译，但是我们的源文件中包含的库的头文件和函数的定义如果不在我们的源文件的当前目录下。

    2. 那么我就需要指明头文件的目录，和库文件的目录。

    3. 但是光指明库文件的目录，还是不可以编译，因为我们不知道我们要链接哪一个库，所以我们还是需要指明库。

    gcc 文件名 -I + 头文件路径 -L + 库文件路径 -l + 库文件名 -o + 想要形成的可执行程序名

    结果：

    1. [lxy@hecs-165234 uselib]$ gcc main.c -I hello/include -L hello/lib -lhello
    2. [lxy@hecs-165234 uselib]$ ./a.out 
    3. sum: 165
    4. hello world [1697122308]

    上面就编译好了，也可以运行出来。

    但是第三种吗，这里没有必要再静态库里面使用，到下面动态库里面我们再使用。

    制作动态库

    动态库和静态库的后缀名有一点区别，动态库是 .so 而静态库是 .a.

    下面，我们先使用指令制作动态库，后面再使用自动化工具。

    gcc -fPIC -c file1.c -o file2.c

    • -fPIC：表示这次要生成的是动态库

    1. [lxy@hecs-165234 mklib]$ gcc -fPIC -c mymath.c -o mymath.o -std=c99
    2. [lxy@hecs-165234 mklib]$ gcc -fPIC -c myprint.c -o myprint.o -std=c99

    这一次生成 .o 文件后，不适用 ar 打包，而是还是使用 gcc 命令

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

    • -shared：表示这次要形成共享库

    下面我们使用自动化工具编写：

    1. .PHONY:all
    2. all:libhello.so libhello.a
    3. ​
    4. libhello.so:mymath_d.o myprint_d.o
    5.         gcc -shared mymath_d.o myprint_d.o -o libhello.so
    6. mymath_d.o:mymath.c
    7.         gcc -c -fPIC mymath.c -o mymath_d.o -std=c99 
    8. myprint_d.o:myprint.c
    9.         gcc -c -fPIC myprint.c -o myprint_d.o -std=c99
    10. ​
    11. libhello.a:mymath.o myprint.o
    12.         ar -rc libhello.a mymath.o myprint.o
    13. mymath.o:mymath.c
    14.         gcc -c mymath.c -o mymath.o -std=c99
    15. myprint.o:myprint.c
    16.         gcc -c myprint.c -o myprint.o
    17. .PHONY:output 
    18. output:
    19.         mkdir -p output/include
    20.         mkdir -p output/lib 
    21.         cp *.h output/include
    22.         cp *.a *.so output/lib
    23. ​
    24. .PHONY:clean
    25. clean:
    26.         rm -rf *.a *.so *.o output

    • 这次，我们使用 makefile 依次形成两个库

    • 首先，我们有一个伪目标，all，而 all 依赖于两个库，所以就需要形成连个库

    • 所以这样就可以一次性形成多个文件了

    • 想要形成动态库，那么就依赖于两个 .o 文件，但是这里为了和下面的 .o 文件不重复，所以需要换一个名字。

    • 要想形成两个 .o 文件，那么又依赖于 . c 文件，然后我们就执行格子的依赖方法即可。

    • 下面我们将 hello 换成 output 表示发布的意思。

    • 然后将.h 文件拷贝到 ./output.include 目录下

    • 将库文件拷贝到 ./output/lib 目录下。

    • 这样就是发布了，然后删除的时候，将所有的 .a .so .o 和 output 都删掉。

    使用动态库

    下面制作好动态库后，我们看一下如何使用动态库。

    我们当然也可以将头文件和库文件分别拷贝到系统目录下。

    但是下面我们不这样做，我们还有其他的做法。

    首先我们还是将 output 目录拷贝到想要使用该库的目录下，这样看起来方便一点，其实不拷贝也可以。

    然后我们像静态库的第二种使用方法一样，直接编译。

    [lxy@hecs-165234 uselib]$ gcc main.c -I./output/include -L ./output/lib -l hello

    • -I（大 i）：指明头文件路径

    • -L：指明库文件路径

    • -l（小 L）：指明哪一个库（去掉前缀去掉后缀）

    这样就编译好了，但是我们难道没有一个疑问吗？

    我们的 ./output/lib 目录下可是有两个 hello 的库的，那么他是选择哪一个呢？

    我们可以使用 ldd 看一下：

    1. [lxy@hecs-165234 uselib]$ ldd a.out 
    2.     linux-vdso.so.1 =>  (0x00007fff55f8c000)
    3.     libhello.so => not found
    4.     libc.so.6 => /lib64/libc.so.6 (0x00007fe1efc3c000)
    5.     /lib64/ld-linux-x86-64.so.2 (0x00007fe1f000a000)

    • 这里看到 a.out 使用了 .so ，也就是说明如果再默认情况下，那么会优先使用动态库。

    • 现在我们运行一下看行不行！

    1. [lxy@hecs-165234 uselib]$ ./a.out 
    2. ./a.out: error while loading shared libraries: libhello.so: cannot open shared object file: No such file or directory

    • 这里运行失败了，我们看一下报错信息。

    • 他显示说，加载共享库的失败，没法打开共享库。

    • 这是为什么呢？

    下面我们就说一下动态库的加载原理：

    • 再一个程序中又动态库的话，那么动态库实际上是可以后面加载的，也就是可以先将代码和数据加载进去。

    • 但是等需要库的时候，再把库里面的代码和数据加载进去。

    • 而一般的代码和数据就加载到一个地址空间的代码段了。

    • 但是动态库一般就加载到“共享区”了（堆和栈中间的一段镂空的位置）。

    • 但是我们再编译的时候，我们以及告诉编译器库在哪了，但是再加载的时候找不到。

    • 因为加载的时候就和编译器没有关系了，就和系统中的加载器有关系了，但是加载器又不知道你的库再哪，所以就报错了。

    • 那么要怎么办呢？

    下面又三种解决方案：

    第一种

    就是将库文件拷贝到系统的 /lib64/ 目录下，那么就可以找到了。

    第二种

    再系统的 /lib64/ 目录下建立软连接，链接到对应的库的位置

    [lxy@hecs-165234 uselib]$ sudo ln -s /home/lxy/lesson/linux107/uselib/output/lib/libhello.so /lib64/libhello.so

    结果：

    1. [lxy@hecs-165234 uselib]$ ls /lib64 | grep hello
    2. libhello.so

    这样就建立好了，那么 a.out 程序也就可以开始运行了。

    1. [lxy@hecs-165234 uselib]$ ./a.out 
    2. sum: 165
    3. hello world [1697164076]

    第三种

    如果不想将程序拷贝到系统目录下，或者也不想建立软连接的话，那么其实可以配置环境变量

    LD_LIBRARY_PATH

    这个环境变量就是每次库文件的搜索路径，所以我们可以将库文件所在的路径添加到该环境变量中：

    [lxy@hecs-165234 uselib]$  LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/home/lxy/lesson/linux107/uselib/output//lib/

    • 添加到该环境变量中

    • 而添加方法就是中间以 : 分割

    下面看一下是否可以执行 a.out

    1. [lxy@hecs-165234 uselib]$ ./a.out 
    2. sum: 165
    3. hello world [1697164557]

    第四种

    由于上面是添加的是该会话的环境变量，如果我们想要永久添加，那么我们可以直接配置到系统中。

    而系统的配置再 /etc/ld.so.conf.d/ 路径下。

    但是由于是系统的，所以配置之后需要刷新一下 ldconfig

    1. //进入到 /etc/ld.so.conf.d/ 目录下
    2. [lxy@hecs-165234 uselib]$ cd /etc/ld.so.conf.d/
    3. [lxy@hecs-165234 ld.so.conf.d]$ ll
    4. total 24
    5. -rw-r--r--  1 root root 26 Jul 19 20:48 bind-export-x86_64.conf
    6. -r--r--r--  1 root root 63 Jan 14  2022 kernel-3.10.0-1160.53.1.el7.x86_64.conf
    7. -r--r--r--  1 root root 63 May  4 23:25 kernel-3.10.0-1160.90.1.el7.x86_64.conf
    8. -r--r--r--  1 root root 63 Jul 24 22:04 kernel-3.10.0-1160.95.1.el7.x86_64.conf
    9. -r--r--r--. 1 root root 63 Nov  9  2018 kernel-3.10.0-957.el7.x86_64.conf
    10. -rw-r--r--  1 root root 17 Jun 21 21:31 mysql-x86_64.conf

    实际上这里的配置其实就是很简单，只需要创建一个文件，然后将对应的库路径写进去就好了。

    但是该文件必须以 .conf 结尾。

    1. [lxy@hecs-165234 ld.so.conf.d]$ cat mylibrary.conf 
    2. /home/lxy/lesson/linux107/uselib/output/lib/

    • 但是这里的创建文件，或者是写入文件都需要 root 权限

    • 等配置结束后，ldconfig 刷新一下就可以了。

    1. [lxy@hecs-165234 ld.so.conf.d]$ /home/lxy/lesson/linux107/uselib/a.out 
    2. sum: 165
    3. hello world [1697165129]

    • 这样就运行出来了。

    上面就是库的制作于使用的全部内容了~

  • 相关阅读:
    计算机视觉与深度学习-全连接神经网络-训练过程-欠拟合、过拟合和Dropout- [北邮鲁鹏]
    【RocketMQ】事务实现原理总结
    4、android 中级控件（1）（图形定制）
    node.js的模块化
    SpringBoot实现1对1、1对多、多对多关联查询——基于SpringBoot和Vue的后台管理系统项目系列博客（十八）
    CSS性能优化
    window-linux文件备份
    how2heap2.31学习(1)
    基于微信小程序的电影院票务系统设计与实现-计算机毕业设计源码+LW文档
    力扣88 - 合并两个有序数组【归并排序思维】
  • 原文地址：https://blog.csdn.net/m0_73455775/article/details/133805946