LD_LIBRARY_PATH和LIBRARY_PATH的区别美高梅手机登录网

作者:电脑系统

优点:

 1 .共享内存
 2 .独立升级组件(插件安装,软件更新)
 3.可以显示动态加载

 优点:

 1. 省空间:linker只会复制你用到的objects。
 2. 打包简单。

编译过程又可以分成两个阶段:编译和汇编。

定义:

 程序在编译时把静态库的代码链接到可执行程序中,在代码运行时不再需要静态库。(简单理解就是把一堆 .o 文件打包到一起,当需要用到就让我们的程序链接进来)

缺点:

 1.当系统中多个应用程序都用了一个动态链接库,但是要求的版本不同,这时动态链接库之间就会相互干扰。
 2.性能开销。动态链接库为了做到“共享代码,但是不共享数据”,引入了不小的开销,调用动态链接库中的函数,需要好几次间接内存访问才能走到函数入口,全局数据也是。

链接的时机:

  1. 编译时,就是源代码被编译成机器代码时(静态链接器负责);
  2. 加载时,也就是程序被加载到内存时(加载器负责);
  3. 运行时,由应用程序来实施(动态链接器负责)。

 优点:

 1. 省空间:linker只会复制你用到的objects。
 2. 打包简单。

动态库

链接的作用(软件复用):

  1. 使得分离编译成为可能;
  2. 动态绑定(binding):使定义、实现、使用分离

目录

静态库的优缺点

静态库与动态库

静态库(static library)就是将相关的目标模块打包形成的单独的文件。使用ar命令。

静态库的优点在于:

  • 程序员不需要显式的指定所有需要链接的目标模块,因为指定是一个耗时且容易出错的过程;
  • 链接时,连接程序只从静态库中拷贝被程序引用的目标模块,这样就减小了可执行文件在磁盘和内存中的大小。

动态库(dynamic library)是一种特殊的目标模块,它可以在运行时被加载到任意的内存地址,或者是与任意的程序进行链接。

动态库的优点在于:

  • 更新动态库,无需重新链接;对于大系统,重新链接是一个非常耗时的过程;
  • 运行中可供多个程序使用,内存中只需要有一份,节省内存。

链接过程

链接器主要是将有关的目标文件彼此相连接生成可加载、可执行的目标文件。链接器的核心工作就是符号表解析和重定位。

 缺点:

 1、如果静态库中有全局变量,那么在几个模块中使用,将会导致全局变量有不同的值,这是非常严重的问题。
 2、静态库编译时,不会进行链接检查,所以这么多静态库的问题,在生成静态库阶段检查不出来。
 3、几个模块,引用同一静态库,如果有一模块没有编译到,会引起巨大的差异导致问题。
 4.产生大量的库文件文件会占空间

定义:

 程序在运行时才去链接动态库的代码,多个程序共享使用库的代码。
 一个与动态库链接的可执行文件仅包含他用到的函数入口地址的一个表,而不是外部函数所在目标文件的机器码。

动态链接(加载、运行时)

在此种方式下,函数的定义在动态链接库或共享对象的目标文件中。在编译的链接阶段,动态链接库只提供符号表和其他少量信息用于保证所有符号引用都有定义,保证编译顺利通过。动态链接器(ld-linux.so)链接程序在运行过程中根据记录的共享对象的符号定义来动态加载共享库,然后完成重定位。在此可执行文件被执行时,动态链接库的全部内容将被映射到运行时相应进程的虚地址空间。动态链接程序将根据可执行程序中记录的信息找到相应的函数代码。  

 

根据链接的时机可知

LIBRARY_PATH环境变量用于在程序编译期间查找动态链接库时指定查找共享库的路径,例如,指定gcc编译需要用到的动态链接库的目录。设置方法如下(其中,LIBDIR1和LIBDIR2为两个库目录):

export LIBRARY_PATH=LIBDIR1:LIBDIR2:$LIBRARY_PATH

LD_LIBRARY_PATH环境变量用于在程序加载运行期间查找动态链接库时指定除了系统默认路径之外的其他路径,注意,LD_LIBRARY_PATH中指定的路径会在系统默认路径之前进行查找。设置方法如下(其中,LIBDIR1和LIBDIR2为两个库目录):

export LD_LIBRARY_PATH=LIBDIR1:LIBDIR2:$LD_LIBRARY_PATH

举个例子,我们开发一个程序,经常会需要使用某个或某些动态链接库,为了保证程序的可移植性,可以先将这些编译好的动态链接库放在自己指定的目录下,然后按照上述方式将这些目录加入到LD_LIBRARY_PATH环境变量中,这样自己的程序就可以动态链接后加载库文件运行了。

静态库

先说说我们为什么需要库?
当有些代码我们大量会在程序中使用比如(scanf,printf等)这些函数我们需要在程序中频繁使用,于是我们就把这些代码编译为库文件,在需要使用时我们直接链接即可。

 缺点:

 1、如果静态库中有全局变量,那么在几个模块中使用,将会导致全局变量有不同的值,这是非常严重的问题。
 2、静态库编译时,不会进行链接检查,所以这么多静态库的问题,在生成静态库阶段检查不出来。
 3、几个模块,引用同一静态库,如果有一模块没有编译到,会引起巨大的差异导致问题。
 4.产生大量的库文件文件会占空间

 静态库搜索路径(由静态链接器负责)

  1. gcc先从-L寻找;
  2. 再找环境变量LIBRARY_PATH指定的搜索路径;
  3. 再找内定目录 /lib /usr/lib /usr/local/lib 这是当初compile gcc时写在程序内的。

静态库的优缺点

定义:

 程序在编译时把静态库的代码链接到可执行程序中,在代码运行时不再需要静态库。(简单理解就是把一堆 .o 文件打包到一起,当需要用到就让我们的程序链接进来)

汇编

汇编实际上指汇编器(as)把汇编语言代码翻译成目标机器指令的过程。目标文件中所存放的也就是与源程序等效的目标的机器语言代码。目标文件由段组成。通常一个目标文件中至少有两个段:

  • 代码段:该段中所包含的主要是程序的指令。该段一般是可读和可执行的,但一般却不可写。
  • 数据段:主要存放程序中要用到的各种全局变量或静态的数据。一般数据段都是可读,可写,可执行的。
  • 静态库
    • 定义:
    • 生成及使用方法:
    • 静态库的优缺点
  • 动态库
    • 定义:
    • 生成及使用方法:
    • 动态库优缺点:

生成及使用方法:

事例程序和上面一样,这里只写出操作步骤

[root@localhost ku]# ls
add.c  add.h  dev.c  dev.h  main.c  mul.c  mul.h  sub.c  sub.h
[root@localhost ku]# gcc -c -fpic *.c
// -fpic   表示编译为位置独立的代码,不用此选项的话编译后的代码是位置相关的所以动态载入时是通过代码拷贝的方式来满足不同进程的需要,而不能达到真正代码段共享的目的。
[root@localhost ku]# ls
add.c  add.h  add.o  dev.c  dev.h  dev.o  main.c  main.o  mul.c  mul.h  mul.o  sub.c  sub.h  sub.o
[root@localhost ku]# rm main.o -rf
[root@localhost ku]# ls
add.c  add.h  add.o  dev.c  dev.h  dev.o  main.c  mul.c  mul.h  mul.o  sub.c  sub.h  sub.o
[root@localhost ku]# gcc -shared -o libmycal.so *.o
[root@localhost ku]# ls
add.c  add.h  add.o  dev.c  dev.h  dev.o  libmycal.so  main.c  mul.c  mul.h  mul.o  sub.c  sub.h  sub.o
[root@localhost ku]# gcc main.c -L. -lmycal
//-L.   表示要连接的库在当前目录中
[root@localhost ku]# ls
add.c  add.h  add.o  a.out  dev.c  dev.h  dev.o  libmycal.so  main.c  mul.c  mul.h  mul.o  sub.c  sub.h  sub.o
[root@localhost ku]# ./a.out 
./a.out: error while loading shared libraries: libmycal.so: cannot open shared object file: No such file or directory
[root@localhost ku]# cp libmycal.so /lib/
//把动态库移动到系统库文件下
[root@localhost ku]# ls
add.c  add.h  add.o  a.out  dev.c  dev.h  dev.o  libmycal.so  main.c  mul.c  mul.h  mul.o  sub.c  sub.h  sub.o
//运行结果
[root@localhost ku]# ./a.out 
8 6
8   6 = 14
8 - 6 = 2
8 * 6 = 48
8 / 6 = 1
//第二种方法,更改库路径
[root@localhost ku]# ./main 
./main: error while loading shared libraries: libmycal.so: cannot open shared object file: No such file or directory
[root@localhost ku]# vim /etc/ld.so.conf.d/mycal.conf //在创建的文件里写上库的路径
//写好路径之后刷新缓冲区
[root@localhost ku]# ldconfig 
//运行结果
[root@localhost ku]# ./main 
8 6
8   6 = 14
8 - 6 = 2
8 * 6 = 48
8 / 6 = 1

先来看看程序编译和链接的过程:

生成及使用方法:

事例程序和上面一样,这里只写出操作步骤

[root@localhost ku]# ls
add.c  add.h  dev.c  dev.h  main.c  mul.c  mul.h  sub.c  sub.h
[root@localhost ku]# gcc -c -fpic *.c
// -fpic   表示编译为位置独立的代码,不用此选项的话编译后的代码是位置相关的所以动态载入时是通过代码拷贝的方式来满足不同进程的需要,而不能达到真正代码段共享的目的。
[root@localhost ku]# ls
add.c  add.h  add.o  dev.c  dev.h  dev.o  main.c  main.o  mul.c  mul.h  mul.o  sub.c  sub.h  sub.o
[root@localhost ku]# rm main.o -rf
[root@localhost ku]# ls
add.c  add.h  add.o  dev.c  dev.h  dev.o  main.c  mul.c  mul.h  mul.o  sub.c  sub.h  sub.o
[root@localhost ku]# gcc -shared -o libmycal.so *.o
[root@localhost ku]# ls
add.c  add.h  add.o  dev.c  dev.h  dev.o  libmycal.so  main.c  mul.c  mul.h  mul.o  sub.c  sub.h  sub.o
[root@localhost ku]# gcc main.c -L. -lmycal
//-L.   表示要连接的库在当前目录中
[root@localhost ku]# ls
add.c  add.h  add.o  a.out  dev.c  dev.h  dev.o  libmycal.so  main.c  mul.c  mul.h  mul.o  sub.c  sub.h  sub.o
[root@localhost ku]# ./a.out 
./a.out: error while loading shared libraries: libmycal.so: cannot open shared object file: No such file or directory
[root@localhost ku]# cp libmycal.so /lib/
//把动态库移动到系统库文件下
[root@localhost ku]# ls
add.c  add.h  add.o  a.out  dev.c  dev.h  dev.o  libmycal.so  main.c  mul.c  mul.h  mul.o  sub.c  sub.h  sub.o
//运行结果
[root@localhost ku]# ./a.out 
8 6
8   6 = 14
8 - 6 = 2
8 * 6 = 48
8 / 6 = 1
//第二种方法,更改库路径
[root@localhost ku]# ./main 
./main: error while loading shared libraries: libmycal.so: cannot open shared object file: No such file or directory
[root@localhost ku]# vim /etc/ld.so.conf.d/mycal.conf //在创建的文件里写上库的路径
//写好路径之后刷新缓冲区
[root@localhost ku]# ldconfig 
//运行结果
[root@localhost ku]# ./main 
8 6
8   6 = 14
8 - 6 = 2
8 * 6 = 48
8 / 6 = 1

动态库优缺点:

动态库搜索路径(由动态链接器负责)

  1. 编译目标代码时指定的动态库搜索路径-L;
  2. 环境变量LD_LIBRARY_PATH指定的动态库搜索路径;
  3. 配置文件/etc/ld.so.conf中指定的动态库搜索路径;
  4. 默认的动态库搜索路径/lib /usr/lib/ /usr/local/lib

动态库

优点:

 1 .共享内存
 2 .独立升级组件(插件安装,软件更新)
 3.可以显示动态加载

静态链接(编译时)

链接器将函数的代码从其所在地(目标文件或静态链接库中)拷贝到最终的可执行程序中。这样该程序在被执行时这些代码将被装入到该进程的虚拟地址空间中。静态链接库实际上是一个目标文件的集合,其中的每个文件含有库中的一个或者一组相关函数的代码。

为创建可执行文件,链接器必须要完成的主要任务:

  1. 符号解析:把目标文件中符号的定义和引用联系起来;
  2. 重定位:把符号定义和内存地址对应起来,然后修改所有对符号的引用。

定义:

 程序在运行时才去链接动态库的代码,多个程序共享使用库的代码。
 一个与动态库链接的可执行文件仅包含他用到的函数入口地址的一个表,而不是外部函数所在目标文件的机器码。

静态库

先说说我们为什么需要库?
当有些代码我们大量会在程序中使用比如(scanf,printf等)这些函数我们需要在程序中频繁使用,于是我们就把这些代码编译为库文件,在需要使用时我们直接链接即可。

编译

编译是指编译器读取源程序(字符流),对之进行词法和语法的分析,将高级语言指令转换为功能等效的汇编代码。

源文件的编译过程包含两个主要阶段:

第一个阶段是预处理阶段,在正式的编译阶段之前进行。预处理阶段将根据已放置在文件中的预处理指令来修改源文件的内容。

主要是以下几方面的处理:

  1. 宏定义指令,如 #define a b 对于这种伪指令,预编译所要做的是将程序中的所有a用b替换,但作为字符串常量的 a则不被替换。还有 #undef,则将取消对某个宏的定义,使以后该串的出现不再被替换。
  2. 条件编译指令,如#ifdef,#ifndef,#else,#elif,#endif等。 这些伪指令的引入使得程序员可以通过定义不同的宏来决定编译程序对哪些代码进行处理。预编译程序将根据有关的文件,将那些不必要的代码过滤掉
  3. 头文件包含指令,如#include "FileName"或者#include 等。 该指令将头文件中的定义统统都加入到它所产生的输出文件中,以供编译程序对之进行处理。
  4. 特殊符号,预编译程序可以识别一些特殊的符号。 例如在源程序中出现的LINE标识将被解释为当前行号(十进制数),FILE则被解释为当前被编译的C源程序的名称。预编译程序对于在源程序中出现的这些串将用合适的值进行替换。

头文件的目的主要是为了使某些定义可以供多个不同的C源程序使用,这涉及到头文件的定位即搜索路径问题。头文件搜索规则如下:

  1. 所有header file的搜寻会从-I开始
  2. 然后找环境变量 C_INCLUDE_PATH,CPLUS_INCLUDE_PATH,OBJC_INCLUDE_PATH指定的路径
  3. 再找默认目录(/usr/include、/usr/local/include、/usr/lib/gcc-lib/i386-linux/2.95.2/include......)

第二个阶段编译、优化阶段,编译程序所要作得工作就是通过词法分析和语法分析,在确认所有的指令都符合语法规则之后,将其翻译成等价的中间代码表示或汇编代码。 

缺点:

 1.当系统中多个应用程序都用了一个动态链接库,但是要求的版本不同,这时动态链接库之间就会相互干扰。
 2.性能开销。动态链接库为了做到“共享代码,但是不共享数据”,引入了不小的开销,调用动态链接库中的函数,需要好几次间接内存访问才能走到函数入口,全局数据也是。

生成及使用方法:

  这里用加减乘除来举例示意:

//创建所需文件
[root@localhost ku]# touch add.c add.h sub.c sub.h mul.c mul.h dev.c dev.h main.c 
[root@localhost ku]# ls
add.c  add.h  dev.c  dev.h  main.c  mul.c  mul.h  sub.c  sub.h
[root@localhost ku]# 
//编写所有文件代码
//add.c
#include"add.h"                                                                                                                       

int add(int x,int y)
{
    return x y;
}
//add.h

#ifndef __ADD_H__
#define __ADD_H__

int add(int x,int y);                                                                                                                                       

#endif // __ADD_H__
//sub.c
#include"sub.h"
int sub(int x,int y)                                                                                                                  
{
    return x-y;
}
//sub.h
#ifndef __SUB_H__
#define __SUB_H__

int sub(int x,int y); 

#endif // __SUB_H__  
//mul.c
#include"mul.h"

int mul(int x,int y)                                                                                                                  
{
    return x*y;
}
//mul.h
#ifndef __MUL_H__
#define __MUL_H__

int mul(int x,int y); 

#endif //__MUL_H__   
//dev.c
#include"dev.h"

int dev(int x,int y)                                                                                                                  
{
    return x/y;
}
//dev.h
#ifndef __DEV_H__ 
#define __DEV_H__

int dev(int x,int y);                                                                                                                 

#endif // __DEV_H__
//main.c
#include<stdio.h>
#include"add.h"
#include"sub.h"
#include"mul.h"
#include"dev.h"

int main()
{
    int a,b;
    scanf("%d%d",&a,&b);
    printf("%d   %d = %dn",a,b,add(a,b));
    printf("%d - %d = %dn",a,b,sub(a,b));
    printf("%d * %d = %dn",a,b,mul(a,b));
    printf("%d / %d = %dn",a,b,dev(a,b));                                                                                            
    return 0;
}

//编译源文件
[root@localhost ku]# ls
add.c  add.h  dev.c  dev.h  main.c  mul.c  mul.h  sub.c  sub.h
[root@localhost ku]# gcc -c *.c //把所有.c文件生成.o文件
[root@localhost ku]# ls
add.c  add.h  add.o  dev.c  dev.h  dev.o  main.c  main.o  mul.c  mul.h  mul.o  sub.c  sub.h  sub.o
[root@localhost ku]# rm main.o -rf  //删除多余的.o文件
[root@localhost ku]# ls
add.c  add.h  add.o  dev.c  dev.h  dev.o  main.c  mul.c  mul.h  mul.o  sub.c  sub.h  sub.o
[root@localhost ku]# 
//生成静态库
[root@localhost ku]# ar -rc libmycal.a *.o
[root@localhost ku]# ls
add.c  add.h  add.o  dev.c  dev.h  dev.o  libmycal.a  main.c  mul.c  mul.h  mul.o  sub.c  sub.h  sub.o
[root@localhost ku]# 
//查看静态库
[root@localhost ku]# ls
add.c  add.h  add.o  dev.c  dev.h  dev.o  libmycal.a  main.c  mul.c  mul.h  mul.o  sub.c  sub.h  sub.o
[root@localhost ku]# ar -tv libmycal.a 
rw-r--r-- 0/0    683 Apr 26 20:46 2018 add.o
rw-r--r-- 0/0    683 Apr 26 20:46 2018 dev.o
rw-r--r-- 0/0    679 Apr 26 20:46 2018 mul.o
rw-r--r-- 0/0    687 Apr 26 20:46 2018 sub.o
[root@localhost ku]# 
//链接静态库生成可执行文件
[root@localhost ku]# ls
add.c  add.h  add.o  dev.c  dev.h  dev.o  libmycal.a  main.c  mul.c  mul.h  mul.o  sub.c  sub.h  sub.o
[root@localhost ku]# gcc main.c -L. -lmycal
[root@localhost ku]# ls
add.c  add.h  add.o  a.out  dev.c  dev.h  dev.o  libmycal.a  main.c  mul.c  mul.h  mul.o  sub.c  sub.h  sub.o
[root@localhost ku]# 
//运行结果
[root@localhost ku]# ls
add.c  add.h  add.o  a.out  dev.c  dev.h  dev.o  libmycal.a  main.c  mul.c  mul.h  mul.o  sub.c  sub.h  sub.o
[root@localhost ku]# ./a.out 
8 3
8   3 = 11
8 - 3 = 5
8 * 3 = 24
8 / 3 = 2
[root@localhost ku]# 

以上是整个静态库的生成及运用过程
总结起来就3步骤:

 首先将源文件编译成目标文件:gcc –c 源文件
 生成静态库:ar –rc lib(库名).a 目标文件
 使用静态库:gcc main.c -L(库的路径) -l(库名)

目标文件(Executable and Linkable Format)

  1. 可重定位(Relocatable)文件:由编译器和汇编器生成,可以与其他可重定位目标文件合并创建一个可执行或共享的目标文件;
  2. 共享(Shared)目标文件:一类特殊的可重定位目标文件,可以在链接(静态共享库)时加入目标文件或加载时或运行时(动态共享库)被动态的加载到内存并执行;
  3. 可执行(Executable)文件:由链接器生成,可以直接通过加载器加载到内存中充当进程执行的文件。

动态库优缺点:

生成及使用方法:

  这里用加减乘除来举例示意:

//创建所需文件
[root@localhost ku]# touch add.c add.h sub.c sub.h mul.c mul.h dev.c dev.h main.c 
[root@localhost ku]# ls
add.c  add.h  dev.c  dev.h  main.c  mul.c  mul.h  sub.c  sub.h
[root@localhost ku]# 
//编写所有文件代码
//add.c
#include"add.h"                                                                                                                       

int add(int x,int y)
{
    return x y;
}
//add.h

#ifndef __ADD_H__
#define __ADD_H__

int add(int x,int y);                                                                                                                                       

#endif // __ADD_H__
//sub.c
#include"sub.h"
int sub(int x,int y)                                                                                                                  
{
    return x-y;
}
//sub.h
#ifndef __SUB_H__
#define __SUB_H__

int sub(int x,int y); 

#endif // __SUB_H__  
//mul.c
#include"mul.h"

int mul(int x,int y)                                                                                                                  
{
    return x*y;
}
//mul.h
#ifndef __MUL_H__
#define __MUL_H__

int mul(int x,int y); 

#endif //__MUL_H__   
//dev.c
#include"dev.h"

int dev(int x,int y)                                                                                                                  
{
    return x/y;
}
//dev.h
#ifndef __DEV_H__ 
#define __DEV_H__

int dev(int x,int y);                                                                                                                 

#endif // __DEV_H__
//main.c
#include<stdio.h>
#include"add.h"
#include"sub.h"
#include"mul.h"
#include"dev.h"

int main()
{
    int a,b;
    scanf("%d%d",&a,&b);
    printf("%d   %d = %dn",a,b,add(a,b));
    printf("%d - %d = %dn",a,b,sub(a,b));
    printf("%d * %d = %dn",a,b,mul(a,b));
    printf("%d / %d = %dn",a,b,dev(a,b));                                                                                            
    return 0;
}

//编译源文件
[root@localhost ku]# ls
add.c  add.h  dev.c  dev.h  main.c  mul.c  mul.h  sub.c  sub.h
[root@localhost ku]# gcc -c *.c //把所有.c文件生成.o文件
[root@localhost ku]# ls
add.c  add.h  add.o  dev.c  dev.h  dev.o  main.c  main.o  mul.c  mul.h  mul.o  sub.c  sub.h  sub.o
[root@localhost ku]# rm main.o -rf  //删除多余的.o文件
[root@localhost ku]# ls
add.c  add.h  add.o  dev.c  dev.h  dev.o  main.c  mul.c  mul.h  mul.o  sub.c  sub.h  sub.o
[root@localhost ku]# 
//生成静态库
[root@localhost ku]# ar -rc libmycal.a *.o
[root@localhost ku]# ls
add.c  add.h  add.o  dev.c  dev.h  dev.o  libmycal.a  main.c  mul.c  mul.h  mul.o  sub.c  sub.h  sub.o
[root@localhost ku]# 
//查看静态库
[root@localhost ku]# ls
add.c  add.h  add.o  dev.c  dev.h  dev.o  libmycal.a  main.c  mul.c  mul.h  mul.o  sub.c  sub.h  sub.o
[root@localhost ku]# ar -tv libmycal.a 
rw-r--r-- 0/0    683 Apr 26 20:46 2018 add.o
rw-r--r-- 0/0    683 Apr 26 20:46 2018 dev.o
rw-r--r-- 0/0    679 Apr 26 20:46 2018 mul.o
rw-r--r-- 0/0    687 Apr 26 20:46 2018 sub.o
[root@localhost ku]# 
//链接静态库生成可执行文件
[root@localhost ku]# ls
add.c  add.h  add.o  dev.c  dev.h  dev.o  libmycal.a  main.c  mul.c  mul.h  mul.o  sub.c  sub.h  sub.o
[root@localhost ku]# gcc main.c -L. -lmycal
[root@localhost ku]# ls
add.c  add.h  add.o  a.out  dev.c  dev.h  dev.o  libmycal.a  main.c  mul.c  mul.h  mul.o  sub.c  sub.h  sub.o
[root@localhost ku]# 
//运行结果
[root@localhost ku]# ls
add.c  add.h  add.o  a.out  dev.c  dev.h  dev.o  libmycal.a  main.c  mul.c  mul.h  mul.o  sub.c  sub.h  sub.o
[root@localhost ku]# ./a.out 
8 3
8   3 = 11
8 - 3 = 5
8 * 3 = 24
8 / 3 = 2
[root@localhost ku]# 

以上是整个静态库的生成及运用过程
总结起来就3步骤:

 首先将源文件编译成目标文件:gcc –c 源文件
 生成静态库:ar –rc lib(库名).a 目标文件
 使用静态库:gcc main.c -L(库的路径) -l(库名)

本文由分分快三计划发布,转载请注明来源

关键词: Linux