当前位置: 澳门新濠3559 > 操作系统 > 正文

库有静态库和动态库,我们就把这些公共代码编

时间:2019-11-20 22:05来源:操作系统
转载于 Linux 中的静态库和动态库简介及生成过程示例 在实际的软件开发项目中,不是每一行代码都需要我们亲自写。在我们的软件产品中,有一些代码(尤其是函数)的出现频率很高,它

转载于

Linux 中的静态库和动态库简介及生成过程示例

在实际的软件开发项目中,不是每一行代码都需要我们亲自写。在我们的软件产品中,有一些代码(尤其是函数)的出现频率很高,它们可以被当作公共代码来反复使用。为了避免重复劳动,我们就把这些公共代码编译为库文件,供需要的程序调用。在Linux中,库分为静态库和动态库两种。

库有静态库和动态库,我们就把这些公共代码编译为库文件。本文对静态库和动态库进行了详细的介绍,并用实际的C代码演示了这两种库的生成过程。

澳门新濠3559 1

 

 在Linux下类库主要有静态库和动态库两种库,首先呢,就说说这两种库的差异:

1.库的分类

一、静态库和动态库简介

众所周知,程序一般需要经过预处理、编译、汇编和链接这几个步骤才能变成可执行的程序。在实际的软件开发中,对于一些需要被许多模块反复使用的公共代码,我们就将它们编译为库文件。

库是一种可执行代码的二进制形式,可以被操作系统载入内存执行。Linux支持的库分为静态库和动态库,动态库又称共享库。一般说来,Linux中的一些重要的库是存放在lib目录下的。

静态库文件的后缀为.a,在Linux下一般命名为libxxx.a。在链接步骤中,连接器将从静态库文件中取得所需的代码,复制到生成的可执行文件中。因此,整个库中的所有函数都被编译进了目标代码中。
动态库文件的后缀为.so,在Linux下一般命名为libxxx.so。相对于静态库,动态库在编译的时候并没有被编译进目标代码中,而是程序执行到相关函数时才调用库中对应的函数。

可以看到,静态库的优点是编译后的执行程序不需要外部的函数库支持,缺点是如果静态函数库改变了,那么你的程序必须重新编译;而动态库在多个应用程序都要使用同一函数库的时候就非常适合,但前提是程序的运行环境中必须提供相应的库。
不管是静态库,还是动态库,都是由*.o目标文件生成的。

 

        静态库:

库有静态库和动态库,linux下静态库为.a,动态库为.so。windows下静态库为.lib,动态库为.dll。

二、静态库生成示例

 

            在程序连接的时候会自动的连接到程序里,
            所以一但编译完成,静态库也就不需要了。静态库通常以.a结尾。
            例如:libutil.a libuuid.a libz.a等。
澳门新濠3559,        动态库:

静态库是在编译的链接阶段链接嵌入到程序中。因此链接了静态库的程序之后与静态库没有了关系,你如果更新了静态库,使用静态库的程序需要重新链接。

1.单个文件生成静态库示例

我们编写如下简单的三个程序文件:test.h、test.c和main.c,在main.c中要调用test.c中实现的函数test。
test.h文件内容:

  1. #include<stdio.h>
  2. voidtest();

test.c文件内容:

  1. #include"test.h"
  2. voidtest()
  3. {
  4. printf("this is in test......n");
  5. }

main.c文件内容:

  1. #include"test.h"
  2. int main()
  3. {
  4. test();
  5. return0;
  6. }

将此三个文件上传到Linux机器上,编译生成静态库文件,之后调用库文件的整个过程如下所示:

  1. ~/zhouzhaoxiong/zzx/mytest/a/single> ll
  2. -rw-------1 zhou dba 53Nov  416:04 main.c
  3. -rw-------1 zhou dba 80Nov  416:04test.c
  4. -rw-------1 zhou dba 36Nov  416:04test.h
  5. ~/zhouzhaoxiong/zzx/mytest/a/single> gcc-c test.c
  6. ~/zhouzhaoxiong/zzx/mytest/a/single> ll
  7. -rw-------1 zhou dba   53Nov  416:04 main.c
  8. -rw-------1 zhou dba   80Nov  416:04test.c
  9. -rw-------1 zhou dba   36Nov  416:04test.h
  10. -rw-rw-rw-1 zhou dba 1624Nov  416:06test.o
  11. ~/zhouzhaoxiong/zzx/mytest/a/single> ar -r libtest.a test.o
  12. ar: creating libtest.a
  13. ~/zhouzhaoxiong/zzx/mytest/a/single> ll
  14. -rw-------1 zhou dba   53Nov  416:04 main.c
  15. -rw-rw-rw-1 zhou dba 1766Nov  416:06 libtest.a
  16. -rw-------1 zhou dba   80Nov  416:04test.c
  17. -rw-------1 zhou dba   36Nov  416:04test.h
  18. -rw-rw-rw-1 zhou dba 1624Nov  416:06test.o
  19. ~/zhouzhaoxiong/zzx/mytest/a/single> gcc-o test main.c libtest.a
  20. ~/zhouzhaoxiong/zzx/mytest/a/single> ll
  21. -rw-------1 zhou dba    52Nov  416:09 main.c
  22. -rwxrwxrwx 1 zhou dba 11876Nov  416:09test
  23. -rw-rw-rw-1 zhou dba  1766Nov  416:06 libtest.a
  24. -rw-------1 zhou dba    80Nov  416:04test.c
  25. -rw-------1 zhou dba    36Nov  416:04test.h
  26. -rw-rw-rw-1 zhou dba  1624Nov  416:06test.o
  27. ~/zhouzhaoxiong/zzx/mytest/a/single> ./test
  28. thisisintest......

我们可以看到,生成库文件的命令是“ar -r libtest.a test.o”,而将静态库文件编译进代码的命令是“gcc -o test main.c libtest.a”。

这样生成了静态库文件libtest.a之后,如果还有其他程序要调用test.c中实现的函数,只需要将test.h和libtest.a拷贝到对应的代码工程中,然后执行类似“gcc -o test main.c libtest.a”这样的命令即可。

 

            在程序编译时并不会被连接到目标代码中,而是在程序运行是才被载入,
            因此在程序运行时还需要动态库存在。通常以.so结尾。如:libz.so。
            因此,静态库相对于共享库来说有更高的效率但是也要消耗更多的空间。

动态库在在运行阶段加载的,不会链接到使用动态库的程序中。有点是一旦修改了动态库,所有使用动态库的程序都会自动加载,无需再次编译。

2.多个文件生成静态库示例

我们编写如下简单的五个程序文件:test.h、test_1.c、test_2.c、test_3.c和main.c,在main.c中要调用test_1.c、test_2.c、test_3.c中实现的函数test_1、test_2、test_3。

test.h文件内容:

  1. #include<stdio.h>
  2. void test_1();
  3. void test_2();
  4. void test_3();

test_1.c文件内容:

  1. #include"test.h"
  2. void test_1()
  3. {
  4. printf("this is in test_1......n");
  5. }

test_2.c文件内容:

  1. #include"test.h"
  2. void test_2()
  3. {
  4. printf("this is in test_2......n");
  5. }

test_3.c文件内容:

  1. #include"test.h"
  2. void test_3()
  3. {
  4. printf("this is in test_3......n");
  5. }

main.c文件内容:

  1. #include"test.h"
  2. int main()
  3. {
  4. test_1();
  5. test_2();
  6. test_3();
  7. return0;
  8. }
  9. ``

将此五个文件上传到Linux机器上,编译生成静态库文件,之后调用库文件的整个过程如下所示:

  1. ~/zhouzhaoxiong/zzx/mytest/a/more> ll
  2. -rw-------1 zxin10 dba 96Nov  416:11 main.c
  3. -rw-------1 zxin10 dba 70Nov  416:04test.h
  4. -rw-------1 zxin10 dba 84Nov  416:04 test_1.c
  5. -rw-------1 zxin10 dba 84Nov  416:04 test_2.c
  6. -rw-------1 zxin10 dba 84Nov  416:04 test_3.c
  7. ~/zhouzhaoxiong/zzx/mytest/a/more> gcc-c test_1.c test_2.c test_3.c
  8. ~/zhouzhaoxiong/zzx/mytest/a/more> ll
  9. -rw-------1 zxin10 dba   96Nov  416:11 main.c
  10. -rw-------1 zxin10 dba   70Nov  416:04test.h
  11. -rw-------1 zxin10 dba   84Nov  416:04 test_1.c
  12. -rw-rw-rw-1 zxin10 dba 1624Nov  416:15 test_1.o
  13. -rw-------1 zxin10 dba   84Nov  416:04 test_2.c
  14. -rw-rw-rw-1 zxin10 dba 1624Nov  416:15 test_2.o
  15. -rw-------1 zxin10 dba   84Nov  416:04 test_3.c
  16. -rw-rw-rw-1 zxin10 dba 1624Nov  416:15 test_3.o
  17. ~/zhouzhaoxiong/zzx/mytest/a/more> ar -r libtest.a test_1.o test_2.o test_3.o
  18. ar: creating libtest.a
  19. ~/zhouzhaoxiong/zzx/mytest/a/more> ll
  20. -rw-------1 zxin10 dba   96Nov  416:11 main.c
  21. -rw-rw-rw-1 zxin10 dba 5158Nov  416:15 libtest.a
  22. -rw-------1 zxin10 dba   70Nov  416:04test.h
  23. -rw-------1 zxin10 dba   84Nov  416:04 test_1.c
  24. -rw-rw-rw-1 zxin10 dba 1624Nov  416:15 test_1.o
  25. -rw-------1 zxin10 dba   84Nov  416:04 test_2.c
  26. -rw-rw-rw-1 zxin10 dba 1624Nov  416:15 test_2.o
  27. -rw-------1 zxin10 dba   84Nov  416:04 test_3.c
  28. -rw-rw-rw-1 zxin10 dba 1624Nov  416:15 test_3.o
  29. ~/zhouzhaoxiong/zzx/mytest/a/more> gcc-o test main.c libtest.a
  30. ~/zhouzhaoxiong/zzx/mytest/a/more> ll
  31. -rw-------1 zxin10 dba    96Nov  416:11 main.c
  32. -rwxrwxrwx 1 zxin10 dba 12008Nov  416:16test
  33. -rw-rw-rw-1 zxin10 dba  5158Nov  416:15 libtest.a
  34. -rw-------1 zxin10 dba    70Nov  416:04test.h
  35. -rw-------1 zxin10 dba    84Nov  416:04 test_1.c
  36. -rw-rw-rw-1 zxin10 dba  1624Nov  416:15 test_1.o
  37. -rw-------1 zxin10 dba    84Nov  416:04 test_2.c
  38. -rw-rw-rw-1 zxin10 dba  1624Nov  416:15 test_2.o
  39. -rw-------1 zxin10 dba    84Nov  416:04 test_3.c
  40. -rw-rw-rw-1 zxin10 dba  1624Nov  416:15 test_3.o
  41. ~/zhouzhaoxiong/zzx/mytest/a/more>./test
  42. thisisin test_1......
  43. thisisin test_2......
  44. thisisin test_3......

我们可以看到,生成静态库文件的命令是“ar -r libtest.a test_1.o test_2.o test_3.o”,而将静态库文件编译进代码的命令是“gcc -o test main.c libtest.a”。

这样生成了静态库文件libtest.a之后,如果还有其他程序要调用test_1.c、test_2.c、test_3.c中实现的函数,只需要将test.h和libtest.a拷贝到对应的代码工程中,然后执行类似“gcc -o test main.c libtest.a”这样的命令即可。

 

       值得注意的是,如果既有静态库又有动态库,在编译时默认的使用动态库。

 

三、动态库生成示例

 

在创建自己的静态库或者动态库时候我想,绝大部分人也都会觉得很轻松,下面就直接贴步骤

2.库的生成

1.单个文件生成动态库示例

我们编写如下简单的三个程序文件:so_test.h、test_a.c和test.c,在test.c中要调用test_a.c中实现的函数test_a。
so_test.h文件内容:

  1. #include<stdio.h>
  2. void test_a();

test_a.c文件内容:

  1. #include"so_test.h"
  2. void test_a()
  3. {
  4. printf("this is in test_a...n");
  5. }

test.c文件内容:

  1. #include"so_test.h"
  2. int main()
  3. {
  4. test_a();
  5. return0;
  6. }

将此三个文件上传到Linux机器上,编译生成动态库文件,之后调用库文件的整个过程如下所示:

  1. ~/zhouzhaoxiong/zzx/mylib/so> ll
  2. -rw-------1 zxin10 dba  95Nov  417:37 so_test.h
  3. -rw-------1 zxin10 dba 109Nov  417:37test.c
  4. -rw-------1 zxin10 dba  84Nov  410:57 test_a.c
  5. ~/zhouzhaoxiong/zzx/mylib/so> gcc test_a.c -fPIC -shared -o libtest.so
  6. ~/zhouzhaoxiong/zzx/mylib/so> ll
  7. -rwxrwxrwx 1 zxin10 dba 8181Nov  417:43 libtest.so
  8. -rw-------1 zxin10 dba   95Nov  417:37 so_test.h
  9. -rw-------1 zxin10 dba  109Nov  417:37test.c
  10. -rw-------1 zxin10 dba   84Nov  410:57 test_a.c
  11. ~/zhouzhaoxiong/zzx/mylib/so> gcctest.c -L.-ltest -o test
  12. ~/zhouzhaoxiong/zzx/mylib/so> ll
  13. -rwxrwxrwx 1 zxin10 dba  8181Nov  417:43 libtest.so
  14. -rw-------1 zxin10 dba    95Nov  417:37 so_test.h
  15. -rwxrwxrwx 1 zxin10 dba 11805Nov  417:44test
  16. -rw-------1 zxin10 dba   109Nov  417:37test.c
  17. -rw-------1 zxin10 dba    84Nov  410:57 test_a.c
  18. ~/zhouzhaoxiong/zzx/mylib/so>./test
  19. thisisin test_a...

注意,“./test”命令执行成功的前提是在环境变量中添加了.so文件所在的路径,这个路径可以在“.bash_profile”文件的“LD_LIBRARY_PATH”变量的值中添加。

我们可以看到,生成动态库文件的命令是“gcc test_a.c -fPIC -shared -o libtest.so”,而将动态库文件编译进代码的命令是“gcc test.c -L. -ltest -o test”(-L.表示当前路径)。

这样生成了动态库文件libtest.so之后,如果还有其他程序要调用test_a.c中实现的函数,只需要将so_test.h和libtest.so拷贝到对应的代码工程中,然后执行类似“gcc test.c -L. -ltest -o test”这样的命令即可(前提是libtest.so所在的路径在环境变量中设置正确)。

 

        静态库:

下面命令在linux环境下执行,以test.c举例

2.多个文件生成动态库示例

我们编写如下简单的五个程序文件:so_test.h、test_a.c、test_b.c、test_c.c和test.c,在test.c中要调用test_a.c、test_b.c、test_c.c中实现的函数test_a、test_b、test_c。

so_test.h文件内容:

  1. #include<stdio.h>
  2. void test_a();
  3. void test_b();
  4. void test_c();

test_a.c文件内容:

  1. #include"so_test.h"
  2. void test_a()
  3. {
  4. printf("this is in test_a...n");
  5. }

test_b.c文件内容:

  1. #include"so_test.h"
  2. void test_b()
  3. {
  4. printf("this is in test_b...n");
  5. }

test_c.c文件内容:

  1. #include"so_test.h"
  2. void test_c()
  3. {
  4. printf("this is in test_c...n");
  5. }

test.c文件内容:

  1. #include"so_test.h"
  2. int main()
  3. {
  4. test_a();
  5. test_b();
  6. test_c();
  7. return0;
  8. }
  9. ``

将此五个文件上传到Linux机器上,编译生成动态库文件,之后调用库文件的整个过程如下所示:

  1. ~/zhouzhaoxiong/zzx/mylib/test_so> ll
  2. -rwxrwxrwx 1 zxin10 dba 8309Nov  509:12 libtest
  3. -rw-------1 zxin10 dba   70Nov  513:44 so_test.h
  4. -rw-------1 zxin10 dba  105Nov  415:25test.c
  5. -rw-------1 zxin10 dba   84Nov  415:25 test_a.c
  6. -rw-------1 zxin10 dba   84Nov  415:25 test_b.c
  7. -rw-------1 zxin10 dba   84Nov  415:25 test_c.c
  8. ~/zhouzhaoxiong/zzx/mylib/test_so> gcc test_a.c test_b.c test_c.c -fPIC -shared -o libtest.so
  9. ~/zhouzhaoxiong/zzx/mylib/test_so> gcctest.c -L.-ltest -o test
  10. ~/zhouzhaoxiong/zzx/mylib/test_so> ll
  11. -rwxrwxrwx 1 zxin10 dba  8309Nov  513:46 libtest.so
  12. -rw-------1 zxin10 dba    70Nov  513:44 so_test.h
  13. -rwxrwxrwx 1 zxin10 dba 11883Nov  513:46test
  14. -rw-------1 zxin10 dba   105Nov  415:25test.c
  15. -rw-------1 zxin10 dba    84Nov  415:25 test_a.c
  16. -rw-------1 zxin10 dba    84Nov  415:25 test_b.c
  17. -rw-------1 zxin10 dba    84Nov  415:25 test_c.c
  18. ~/zhouzhaoxiong/zzx/mylib/test_so>./test
  19. thisisin test_a...
  20. thisisin test_b...
  21. thisisin test_c...

注意,“./test”命令执行成功的前提仍然是在环境变量中添加了.so文件所在的路径,这个路径可以在“.bash_profile”文件的“LD_LIBRARY_PATH”变量的值中添加。

我们可以看到,多个文件生成动态库文件的命令是“gcc test_a.c test_b.c test_c.c -fPIC -shared -o libtest.so”,而将动态库文件编译进代码的命令是“gcc test.c -L. -ltest -o test”(-L.表示当前路径)。

这样生成了动态库文件libtest.so之后,如果还有其他程序要调用test_a.c、test_b.c、test_c.c中实现的函数,只需要将so_test.h和libtest.so拷贝到对应的代码工程中,然后执行类似“gcc test.c -L. -ltest -o test”这样的命令即可(前提是libtest.so所在的路径在环境变量中设置正确)。

 

            (1) 编写库文件testlib.c

动态库的生成

四、总结

有关生成静态库和动态库的命令,说明如下:

第一,在本文中,我们使用的生成静态库的命令形如“ar -r test.a test.o”,其中,-r是replace的意思,表示如果当前插入的模块名已经在库中存在,则替换同名的模块。我们也可以用形如“ar -cr test.a test.o”的命令来生成静态库,其中-c是create的意思,表示生成。

第二,在本文中,我们使用的生成动态库文件的命令形如“gcc test_a.c -fPIC -shared -o libtest.so”,其中,fPIC表示编译为位置独立的代码,shared表示生成的库为共享库。将动态库文件编译进代码的命令是“gcc test.c -L. -ltest -o test”,-L指定库查找的位置(注意L后面还有'.'),表示在当前目录下查找(如果在当前目录下的lib目录下查找,可以写成-L./lib);-l则指定函数库名,其中的lib和.so省略(如这里的libtest.so就简写为test)。

第三,使用ldd命令可以查看一个可执行程序依赖的共享库,该命令的使用示例如下所示:

  1. ~/zhouzhaoxiong/zzx/mylib/test_so>lddtest
  2. linux-vdso.so.1=>  (0x00007fff1db6e000)
  3. libtest.so =>/home/zhou/lib/libtest.so (0x00007fdbfff21000)
  4. libc.so.6=>/lib64/libc.so.6(0x00007fdbffb95000)
  5. /lib64/ld-linux-x86-64.so.2(0x00007fdc00124000)

可以看到,可执行文件test依赖于四个共享库,其中libtest.so位于当前用户的lib目录下。

本文永久更新链接地址:

中的静态库和动态库简介及生成过程示例 在实际的软件开发项目中,不是每一行代码都需要我们亲自写。在我们的软件产品中,有一些...

            (2)编写一个头文件用于声明我们使用的函数testlib.h

gcc -share test.c -o libtest.so

            (3) 编译testlib.c:    

 

                    gcc -c testlib.c
            (4) 用ar创建一个归档文件:    

静态库的生成

                     ar crv libfirst.a testlib.o         生成libfirst.a
            (5)在某些系统中还要为静态库生成一个内容表
                    ranlib libfirst.a
            (6)然后就可以使用该静态库了
                eg:
                [root@localhost Source]# vi zyx.c
                [root@localhost Source]# gcc -o zyx zyx.c -I./lib -L./lib -lfirst (-static)
                [root@localhost Source]# ls
                hello HelloWorld.h static.exe zyx
                HelloWorld.cpp lib StaticLibTest.c zyx.c
                [root@localhost Source]# ./zyx

由于静态库是在链接阶段链接的,因此静态库实际上就是编译阶段的.o目标文件的归档文件

 

gcc -c test.c会生成test.o

    动态库:

ar -r libtest.a test.o

        通过一个例子来介绍如何生成一个动态库。这里有一个头文件:so_test.h, 三个.c文件:test_a.c、test_b.c、test_c.c

可以将多个.o文件打包到一个库中

        我们将这几个文件编译成一个动态库:libtest.so。

 

    

3.库的加载

        gcc test_a.c test_b.c test_c.c -fPIC -shared -o libtest.so

gcc默认会在/lib 和/user/lib下查找库

        

比如test.c会使用到加密库中的函数

        我们已经成功生成了一个自己的动态链接库libtest.so,
        下面我们通过一个程序来调用这个库里的函数。假设程序的源文件为:test.c

gcc test.c -lcrypto -o test

        

gcc会自动到/lib和/usr/lib路径下查找libcrypto.a或者libcrypto.so

        将test.c与动态库libtest.so链接生成执行文件test: $ gcc test.c -L. -ltest -o test
        测试是否动态连接,如果列出libtest.so,那么应该是连接正常了

 

 

当库不在/lib和 /usr/lib路径下时,需要手动指定库链接

        在使用动态库的时候,还有一点会经常遇到的需要注意:

可以使用-L,比如在当前路径下查找库

           调用动态库的时候有几个问题会经常碰到,有时,明明已经将库的头文件所在目录 
           通过 “-I” include进来了,库所在文件通过 “-L”参数引导,并指定了“-l”
           的库名,但通过ldd命令察看时,就是死活找不到你指定链接的so文件,这时你要作
           的就是通过修改LD_LIBRARY_PATH或者/etc/ld.so.conf文件来指定动态库的目录。
           通常这样做就可以解决库无法链接的问题了 
           1.修改/etc/ld.so.conf,加入自己的动态库的路径
           然后/sbin/ldconfig 使配制文件生效
           2。直接把自己的动态库文件拷贝到 /etc/ld.so.conf中的任意路径
           3.export LD_LIBRARY_PATH=/home/kui/:$LD_LIBRARY_PAT(=的前后不能有空格)或者export

gcc test.c -L. -lcrypto -o test

            $LD_LIBRARY_PATH:LD_LIBRARY_PATH=/home/kui/
           使用echo $LD_LIBRARY_PATH可以看到路径是否设置成功

 

 

另外程序链接库时如果没有使用-static选项,一般会优先使用动态库。

    上面这些都是最基本的,在工作中,这些往往满足不了我们的需要,比如说,我们生成一个动态库,要依赖与多个动态库或者静态库,或者我生成静态库的时候要依赖于其它的静态库,这个时候怎么弄?

要加载静态库需要使用-static选项

    关于依赖于多个静态库或者动态库生成一个动态库的,网上有很多资源,也不多说,直接贴一个示例:

gcc test.c -lcrypto -static -o teststatic

    gcc -g Protocol.c -fPIC -shared libadd.a libade.a -o libScanApi.so -I ./ -L ./ -lfrt6 -I /usr/local/include/libusb-1.0/ -L /usr/local/lib/ -lusb-1.0

明显可以看到teststatic比test要大很多。

    在这里面,我生成了一个 libScanApi.so的库,它依赖于静态库 libadd.a libade.a(静态库如若是自己编译的,在编译时候要加上-fPIC -shared),动态库libfrt6.so和libusb-1.0.so。其中,-I后面接的是库头文件路径, -L后面接的是库路径,如果还有更多的静态库或者动态库需要被依赖,则在后面一次添加

因为静态库会链接到程序中。

 

 

    关于静态库,似乎可用的资料就不是那么多了

    前不久遇到这样的一个问题,我依赖于几个.c文件和两个静态库的动态库,需要提供一个静态库版本给客户,当时感觉很郁闷,因为两个静态库我都是没有源码的,网上找了许久也没有找到自己想要的,后来求助一大神,终于完美解决。

    我现在找不到那个网址了,不过还好保存的还有截图,可以参阅一下,同时也建议,如果要经常使用到静态库,可以先细读一下ar的参数。    

澳门新濠3559 2

    其实静态库也就相当于一个压缩包,里面存放的是一些.o文件,把需要的.o放在一起打包,就生成了静态库。ar x A.a则正相反,是把生成A.a的.o文件给解出来,这样,即便是第三方库我们也可以获得其.o。而生成静态库的时候正是依赖于.o文件,所以我们就可以依赖于多个静态库生成一个静态库了。

    但是有的时候,貌似这样还会错误,比如我上次用的是libusb-1.0.a的静态库,在解压重新打包编译之后,出现了这样的问题

澳门新濠3559 3

    从错误中,可以很明显的看到clock和pthread,很明显,是缺少pthread库和lrt(实时时钟)库的支持,于是在编译时候在后面加上-lpthread 和-lrt就so easy 解决了

    gcc -o tets testScanApi.c -L. -lFP_Ara -lpthread -lrt

编辑:操作系统 本文来源:库有静态库和动态库,我们就把这些公共代码编

关键词:

  • 上一篇:没有了
  • 下一篇:没有了