Linux中创建静态库和动态库[1]

合集下载

linux静态库的通俗理解

linux静态库的通俗理解

linux静态库的通俗理解说到Linux静态库,首先我们需要明白什么是库(Library)。

在程序开发中,往往会使用到一些常用的函数文件,例如输入输出、字符串操作等。

而这些函数文件的代码被编译成了二进制代码,并将这些函数放在一起组成一个库文件。

当我们需要调用这些函数时,只需要在程序中引用这个库文件,就可以直接使用其中的函数了。

这些库文件包括动态库和静态库两种。

那么什么是静态库呢?静态库是一种静态链接库,也被称为静态链接库。

静态库和动态库最大的不同之处在于,它们是在编译时链接到程序中的。

也就是说,在程序运行之前,静态库的代码已经全部被复制到了程序中。

在运行期间,程序会调用静态库中的函数,而不是再次加载。

相对于动态库,静态库有以下几个优点:1.移植性更好:静态库在编译时已经被链接到程序中,不需要引用外部库,因此更加便于移植到其他系统中。

3.更容易控制版本:静态库在编译时已经被链接到程序中,在运行时不会受到环境变量的影响,因此更容易控制版本。

静态库的使用方法相对简单,下面简要介绍一下:1.创建静态库文件:使用ar命令将多个.o文件打包成一个.a文件,例如:ar rcs libtest.a test1.o test2.o test3.o其中,r表示将test1.o、test2.o、test3.o文件打包成libtest.a文件,c表示在没有libtest.a文件时自动创建它,s表示为库添加索引。

2.使用静态库文件:在程序中引用静态库文件,例如:gcc -o program program.c -L./ -ltest其中-L./表示在当前目录查找库文件,-ltest表示使用名为libtest.a的静态库文件。

1.静态库不能与动态库同时使用:由于静态库已经被编译到程序中,如果同时使用动态库,可能会出现重复定义的问题。

3.静态库体积相对较大:由于静态库已经被编译到程序中,所以会增加程序的体积。

综上所述,静态库是一种很常用的库文件形式,在程序开发中是非常必要的。

静态库和动态库编译

静态库和动态库编译

静态库和动态库编译静态库和动态库是编程中常用的两种库文件形式,本文将介绍它们的编译过程和使用方法。

1. 静态库编译静态库是一种在编译时被链接到程序中的库文件,它包含了程序所依赖的所有函数和数据结构,因此程序在运行时不需要再加载库文件。

静态库的编译过程包括以下步骤:(1)创建一个或多个源文件,使用编译器将它们编译成目标文件(.o 或 .obj)。

(2)将多个目标文件打包成一个静态库文件,通常使用 ar 工具完成此操作。

例如,在 Linux 系统下,可以使用以下命令创建名为 libfoo.a 的静态库文件:$ ar rcs libfoo.a foo1.o foo2.o ...其中,rcs 参数分别表示创建、向库文件中添加目标文件和生成索引表。

(3)在编译器中使用静态库,需要将其链接到目标程序中。

在Linux 系统下,可以使用以下命令编译名为 main.c 的源文件和名为libfoo.a 的静态库文件:$ gcc -o main main.c -L. -lfoo其中,-L 参数指定库文件搜索路径,. 表示当前目录;-l 参数指定链接库文件,实际上是将其前缀 lib 和后缀 .a 去掉,即 foo。

2. 动态库编译动态库是一种在程序运行时动态加载的库文件,它只包含程序所需要的部分函数和数据结构,因此可以减小程序的尺寸和加载时间。

动态库的编译过程包括以下步骤:(1)创建一个或多个源文件,使用编译器将它们编译成目标文件。

(2)将多个目标文件打包成一个共享库文件,通常使用 ld 或链接器完成此操作。

例如,在 Linux 系统下,可以使用以下命令创建名为 libfoo.so 的动态库文件:$ gcc -shared -o libfoo.so foo1.o foo2.o ...其中,-shared 参数表示生成共享库文件。

(3)在编译器中使用动态库,需要将其链接到目标程序中。

在Linux 系统下,可以使用以下命令编译名为 main.c 的源文件和名为libfoo.so 的动态库文件:$ gcc -o main main.c -L. -lfoo其中,-L 和 -l 参数的含义同静态库。

手把手教你调试LinuxC++代码(一步到位包含静态库和动态库调试)

手把手教你调试LinuxC++代码(一步到位包含静态库和动态库调试)

⼿把⼿教你调试LinuxC++代码(⼀步到位包含静态库和动态库调试)⼿把⼿教你调试Linux C++ 代码软件调试本⾝就是⼀项相对复杂的活动,他不仅要求调试者有着清晰的思路,⽽且对调试者本⾝的技能也有很⾼的要求。

Windows下Visual Studio为我们做了很多的⼯作,使初学者基本上可以获得⼀个所见即所得的调试体验,相对来说也⽐较容易上⼿。

然⽽在linux平台下,⼀切都显得有些不同,倒不是说GDB有多难,只是对于习惯了visual studio的⼈来说刚开始会有些不适应。

然⽽对于那些在windows 平台下使⽤windbg调试代码的⼈来说,情况会好很多,但是也要有个思维⽅式的转变以及调试命令的再适应过程。

本⽂将带你开启GDB 调试 Linux 下C/C++的⼤门。

Agenda1. 准备条件2. GDB调试单执⾏⽂件3. GDB调试静态链接库4. GDB调试动态链接库1. 准备条件由于Linux下没有visual studio,对于程序的编译需要借助makefile,下⾯我先晒出⼀个简单的makefile,不求⼤⽽全,⼩巧可⽤就好。

#makefileCC=gccCXX=g++RM=rm -fCPPFLAGS=-gLDFLAGS=-gLDLIBS=AR=arSRCS= OBJS=$(subst .cc,.o,$(SRCS))all: mainmain: $(OBJS)$(CXX) $(LDFLAGS) -o main $(OBJS) -L. $(LDLIBS)main.o: functions.h testobj.hfunctions.o: functions.h clean:$(RM) $(OBJS)all-clean: clean$(RM) main如下是相关的三个⽂件直接copy就可以使⽤//functions.h1 #include<iostream>2 #include"functions.h"5int main()6 {7 std::cout << "Enter two numbers:" << std::endl;8int v1 = 0, v2 = 0;9 std::cin >> v1 >> v2;10 std::cout << "The sum of " << v1 << " and " << v211 << " is " << v1 + v2 << std::endl;1213 function();1415return0;16 }1 #include<iostream>2int function(void)3 {4 std::cout << "I am in a function!" << std::endl;5return0;6 }1int function(void);将这4个⽂件放⼊⼀个⽬录下,到这个⽬录下直接执⾏make就会产⽣⼀个可执⾏⽂件main。

linux动态库和静态库调用方法

linux动态库和静态库调用方法

linux动态库和静态库调用方法
在Linux操作系统中,动态库和静态库的调用方法如下:
1. 动态库(Shared Library):动态库在程序运行时被载入内存,可以被多个程序同时使用,节省内存空间。

在Linux中,动态库一般存放在/usr/lib或/lib目录下。

调用方法:在程序中使用extern "C"来声明函数接口,然后通过dlopen(), dlsym()等函数来动态调用动态库中的函数。

2. 静态库(Static Library):静态库在程序编译时被包含进可执行程序中,每个程序都有一份自己的库副本。

静态库一般存放在/usr/lib或/lib目录下。

调用方法:在程序中直接使用静态库中的函数,不需要额外的调用方法。

只需要在编译时使用"-l"选项指定要链接的库名,例如"gcc -o test test.c -lmylib"。

需要注意的是,对于动态库和静态库的使用,一般建议优先使用动态库,因为这样可以节省内存空间,并且可以在不停止程序运行的情况下更新库文件。

第1页/ 共1页。

详解Linux动态库生成与使用指南

详解Linux动态库生成与使用指南

详解Linux动态库⽣成与使⽤指南Linux下动态库⽂件的⽂件名形如 libxxx.so,其中so是 Shared Object 的缩写,即可以共享的⽬标⽂件。

在链接动态库⽣成可执⾏⽂件时,并不会把动态库的代码复制到执⾏⽂件中,⽽是在执⾏⽂件中记录对动态库的引⽤。

程序执⾏时,再去加载动态库⽂件。

如果动态库已经加载,则不必重复加载,从⽽能节省内存空间。

Linux下⽣成和使⽤动态库的步骤如下:编写源⽂件。

将⼀个或⼏个源⽂件编译链接,⽣成共享库。

通过 -L<path> -lxxx 的gcc选项链接⽣成的libxxx.so。

把libxxx.so放⼊链接库的标准路径,或指定 LD_LIBRARY_PATH,才能运⾏链接了libxxx.so的程序。

下⾯通过实例详细讲解。

编写源⽂件建⽴⼀个源⽂件: max.c,代码如下:int max(int n1, int n2, int n3){int max_num = n1;max_num = max_num < n2? n2: max_num;max_num = max_num < n3? n3: max_num;return max_num;}编译⽣成共享库:gcc -fPIC -shared -o libmax.so max.c我们会得到libmax.so。

实际上上述过程分为编译和链接两步, -fPIC是编译选项,PIC是 Position Independent Code 的缩写,表⽰要⽣成位置⽆关的代码,这是动态库需要的特性; -shared是链接选项,告诉gcc⽣成动态库⽽不是可执⾏⽂件。

上述的⼀⾏命令等同于:gcc -c -fPIC max.cgcc -shared -o libmax.so max.o为动态库编写接⼝⽂件为了让⽤户知道我们的动态库中有哪些接⼝可⽤,我们需要编写对应的头⽂件。

建⽴ max.h ,输⼊以下代码:#ifndef __MAX_H__#define __MAX_H__int max(int n1, int n2, int n3);#endif测试,链接动态库⽣成可执⾏⽂件建⽴⼀个使⽤max函数的test.c,代码如下:#include <stdio.h>#include "max.h"int main(int argc, char *argv[]){int a = 10, b = -2, c = 100;printf("max among 10, -2 and 100 is %d.\n", max(a, b, c));return 0;}gcc test.c -L. -lmax ⽣成a.out,其中-lmax表⽰要链接libmax.so。

第三阶段学习总结,静态库和动态库的创建和使用C 篇

第三阶段学习总结,静态库和动态库的创建和使用C  篇

利用以上代码和文件创建动态库: g++ -fpic -shared -o libmyfun.so fun1.o fun2.o fun3.o 其中: -fpic 使输出的对象模块是按照可重定位地址方式生成的。 -shared 指定把对应的源文件生成对应的动态链接库文件 libmyfun.so 文件。下面看一下如何 使用对应的动态链接库。 g++ -o somyfuntest main.cpp -L . -lmyfun 与静态库的利用不同的是,在默认情况下,当程序运行时,系统会搜索/lib 和/usr./lib 库,如果连接库没有存在这两个目录下,系统将不能找到链接库,程序会终止运行。所以, 一般情况下我们需要手动的添加路径或者更改 LD_LIBRARY_PATH 的环境变量。 前者,我们需要把当前生成的动态库的路径加到/usr/local/lib 下面。我一般情况下习惯 于用后一种方法,我习惯于这样做,export LD_LIBRARY_PATH=$PWD,然后我们就可 以执行可执行文件 somyfuntest 了。 库函数就简单介绍到这里,想了解更深尚需时日。“冰冻三尺非一日之寒”,对嵌入式的 学习非一朝一日所能完成的,短短的几个月,时间之紧迫,内容之丰盛,尚需多反馈总结啊!
#include"head.h" int main() { fun1(); fun2(); fun3();
return 0; }
利用以上的代码和文件创建静态库:
利用 G++生成对应目标文件: g++ –c fun1.c fun2.c fun3.c 如果对应的文件没有错误,g++会对文件进行编译生成 fun1.o、fun2.o 和 fun3.o 三个目标 文件(相当于 windows 下的 obj 文件)。然后用 ar 创建一个名字为 libstr.a 的库文件,并把 fun1.o、fun2.o 和 fun3.o 内容插入到对应的库文件中。

大学专业课Linux第8章-创建与使用库


14
ar命令范例: • 范例6:调整库中成员的顺序:将b.c移动到a.c之前 [root@localhost ~]# ar -mb a.c two.bak b.c
使用"m"关键字。与"r"关键字一样,它也有3个修饰 符"a","b", "i"。
15
系统函数库的使用
• 单独查看某个函数的方法: • 第一步: 通过ar 命令的x 选项将目标文件从函数库中分 离出来。 • ar x /usr/lib/libc.a fprintf.o • 第二步:执行nm命令查看相应的目标文件中提供哪些 函数。 • 例如:
9
ar命令范例:
• 范例1: 打包文件 [root@localhost ~]# ar rv one.bak a.c b.c //打包 a.c b.c文件 ar: 正在创建 one.bak a - a.c a - b.c [root@localhost ~]# ar rv two.bak *.c //打包以.c结尾的文件 ar: 正在创建 two.bak a - a.c a - b.c a - c.c a - d.c [root@localhost ~]#
7
ar参数 • 选项参数
– – – –
a<成员文件> 将文件插入备存文件中指定的成员文件之后。 b<成员文件> 将文件插入备存文件中指定的成员文件之前。 c 建立备存文件。 f 为避免过长的文件名不兼容于其他系统的ar指令,因此可 利用此参数,截掉要放入备存文件中过长的成员文件名称。
8
ar参数
– i<成员文件> 将文件插入备存文件中指定的成员文件之前。 – o 保留备存文件中文件的日期。 – s 若备存文件中包含了对象模式,可利用此参数建立备存 文件的符号表。 – S 不产生符号表。 – u 只将日期较新文件插入备存文件中。 – v 程序执行时显示详细的信息。 – V 显示版本信息。

Linux下g++编译与使用静态库和动态库的方法

Linux下g++编译与使⽤静态库和动态库的⽅法在windows环境下,我们通常在IDE如VS的⼯程中开发C++项⽬,对于⽣成和使⽤静态库(*.lib)与动态库(*.dll)可能都已经⽐较熟悉,但是,在linux环境下,则是另⼀套模式,对应的静态库(*.a)与动态库(*.so)的⽣成与使⽤⽅式是不同的。

刚开始可能会不适应,但是⽤多了应该会习惯这种使⽤,因为步骤上并没有VS下配置那么繁琐。

下⾯就分别总结下linux下⽣成并使⽤静态库与动态库的⽅法:(由于是C++项⽬,所以编译器⽤的g++,但是与gcc的使⽤是相通的)⾸先是准备⼯作,把我们需要封装成库⽂件的函数的头⽂件与源⽂件写好,如下://myAPI.hint ADD(int a, int b);int MINUS(int a, int b);//myAPI.cpp#include "myAPI.h"int ADD(int a, int b){return a + b;}int MINUS(int a, int b){return a - b;}接下来准备⼀个测试⽤的主函数源⽂件://main.cpp#include "myAPI.h"#include <iostream>int main(){std::cout << "1 + 1 = " << ADD(1, 1) << std::endl;std::cout << "1 - 1 = " << MINUS(1, 1) << std::endl;return 0;}最后,先编译我们的 myAPI.cpp ⽂件⽣成 myAPI.o ⽬标⽂件g++ -c myAPI.cpp1.⽣成静态库并使⽤Linux下⽤⽣成静态库的命令 ar 处理 myAPI.o ⽂件⽣成静态库⽂件,⽣成的库⽂件应遵循规范,及linux下库⽂件加“lib”前缀。

创建和使用静态库(问题:undefined reference)

创建和使用静态库(问题:undefinedreference)1.用vim创建一个静态库库中包含4个函数,分别为加、减、乘、除,源程序文件取名为static_lib.c,代码如下:1//this is a static lib function made at2011.11.1523int add(int a,int b)4{5return a+b;67}89int sub(int a,int b)10{11return a-b;1213}1415int mul(int a,int b)16{17return a*b;1819}2021int div(int a,int b)22{23return a/b;2425}2、在shell中编译static_lib.c成静态库static_lib.a26[HLinuxH@M-S temp]$vim static_lib.c//创建源文件2728[HLinuxH@M-S temp]$gcc-c static_lib.c//编译源文件使它生成一个可重定位的目标文件2930[HLinuxH@M-S temp]$ls//查看目录文件,有发现生成了static_lib.o31static_lib.c static_lib.o3233[HLinuxH@M-S temp]$ar rcs static_lib.a static_lib.o//用ar工具生成静态库,参数r表示把列表34//中目标文件加入到静态库中;参数c表示35//若指定静态库不存在则创建该库;参数s36//表示更新静态库文件索引使其包含新加入37//的目标文件内容。

3839[HLinuxH@M-S temp]$ls//查看目录,有发现生成了static_lib.a40static_lib.a static_lib.c static_lib.o4142[HLinuxH@M-S temp]$3、用vim创建一个头文件,使应用程序可以正确引用该库中的全局符号,头文件源文件命名为static_lib.h,代码如下:43//this is the lib declare function for static_lib.a made at2011.11.154445extern int add(int a,int b);//declare add function46extern int sub(int a,int b);//declare sub function47extern int mul(int a,int b);//declare mul function48extern int div(int a,int b);//declare div function用vim创建一个应用程序并命名为main.c4、该程序实现功能很简单:接受用户输入两个数,调用static_lib.a库中的函数进行加减乘除。

Linux系统命令以及库的建立

所讲内容涉及三个方面:1,终端需要用到的基本指令2,gcc编译器3,动态库和静态库的创建和使用常用的指令:现阶段我们经常用到mkdir,vim,gcc,rm,cp,tar,ls,mv着几个指令。

在我们打开终端时,一般都是先创立一个文件,这时用到mkdir 命令,然后进入到目录里面写代码,这时要用到vim指令去创建一个源文件(即.c文件);在源文件中可以用yy/dd/p/u对内容进行复制/删除/粘贴/恢复等操作编辑完成后我们会对源文件进行编译,在编译中为了保留相应可执行文件,一般用到gcc例里面的-o,如果需要调试还会用到-g生成调试文件;如果我们想要删除一个文件就用rm,这时会出现询问行,输入y 或者n选择;如果想要删除一个目录,一般用rm –rf指令,但是这个指令不会询问而是直接删除。

拷贝文件时经常用到cp和cp -r指令。

cp指令是直接拷贝源文件,而cp –r用于拷贝目录(文件夹)。

其他的指令在使用时如果不记得可以借用man指令来查。

gcc编译器:gcc编译器的优点:1)可编译多种语言;2)是一个交叉编译器交叉编译的结果是编译出来能在目标机上执行的代码。

为什么需要交叉编译呢?因为不同的cpu有着不同的汇编,不同的汇编有不同的机器码。

gcc编译过程可以细分为四个过程:预处理、编译、汇编、链接预处理做了什么?预处理做了三个工作,分别是:头文件展开(把.h的内容加载到.c文件中)、宏替换、条件编译。

库静态库(.a):执行程序之前就已经加入到执行代码之中,成为执行程序的一部分。

因此静态库具有容易布置,事先就知道哪些代码要执行,运行效率高,但是产生的可执行文件体积大,难以升级。

多用于升级不多的软件动态库(.so):难以布置,运行效率低,产生的可执行文件小,易于升级。

用于升级多的软件静态库的创建与调用:第一步:生成可执行文件gcc –c 源文件(.c文件)第二步:创建库ar rcs lib库名.a 可执行文件(.o文件)例如:创建一个加法的库: gcc –c add.c生成可执行文件,然后ar rcs libadd.c add.o生成库,最后gcc main.c –L. –ladd调用这个库动态库的创建与调用:创建:gcc –shared –fPIC –o 库名.so 源文件.c调用:gcc 源文件.c ./库名.so –o 可执行文件名例如:gcc –shared –fPIC –o libadd.so add.c创建加法动态库gcc main.c ./libadd.so –o main 调用加法动态库。

  1. 1、下载文档前请自行甄别文档内容的完整性,平台不提供额外的编辑、内容补充、找答案等附加服务。
  2. 2、"仅部分预览"的文档,不可在线预览部分如存在完整性等问题,可反馈申请退款(可完整预览的文档不适用该条件!)。
  3. 3、如文档侵犯您的权益,请联系客服反馈,我们会尽快为您处理(人工客服工作时间:9:00-18:30)。

我们通常把一些公用函数制作成函数库,供其它程序使用。
函数库分为静态库和动态库两种。
静态库在程序编译时会被连接到目标代码中,程序运行时将不再需要该静态库。
动态库在程序编译时并不会被连接到目标代码中,而是在程序运行是才被载入,因此在程序
运行时还需要动态库存在。

本文主要通过举例来说明在Linux中如何创建静态库和动态库,以及使用它们。
在创建函数库前,我们先来准备举例用的源程序,并将函数库的源程序编译成.o文件。
第1步:编辑得到举例的程序--hello.h、hello.c和main.c;
hello.h(见程序1)为该函数库的头文件。
hello.c(见程序2)是函数库的源程序,其中包含公用函数hello,该函数将在屏幕上输出"Hello
XXX!"。

main.c(见程序3)为测试库文件的主程序,在主程序中调用了公用函数hello。
程序1: hello.h
#ifndef HELLO_H
#define HELLO_H

void hello(const char *name);
#endif //HELLO_H
程序2: hello.c

#include
void hello(const char *name)
{
printf("Hello %s!\n", name);
}

程序3: main.c
#include "hello.h"
int main()
{
hello("everyone");
return 0;
}

第2步:将hello.c编译成.o文件;
无论静态库,还是动态库,都是由.o文件创建的。因此,我们必须将源程序hello.c通过gcc
先编译成.o文件。

在系统提示符下键入以下命令得到hello.o文件。
# gcc -c hello.c
#
(注1:本文不介绍各命令使用和其参数功能,若希望详细了解它们,请参考其他文档。)
(注2:首字符"#"是系统提示符,不需要键入,下文相同。)
我们运行ls命令看看是否生存了hello.o文件。
# ls
hello.c hello.h hello.o main.c
#
(注3:首字符不是"#"为系统运行结果,下文相同。)
在ls命令结果中,我们看到了hello.o文件,本步操作完成。
下面我们先来看看如何创建静态库,以及使用它。
第3步:由.o文件创建静态库;
静态库文件名的命名规范是以lib为前缀,紧接着跟静态库名,扩展名为.a。例如:我们将
创建的静态库名为myhello,则静态库文件名就是libmyhello.a。在创建和使用静态库时,需
要注意这点。创建静态库用ar命令。

在系统提示符下键入以下命令将创建静态库文件libmyhello.a。
# ar cr libmyhello.a hello.o
#
我们同样运行ls命令查看结果:
# ls
hello.c hello.h hello.o libmyhello.a main.c
#
ls命令结果中有libmyhello.a。
第4步:在程序中使用静态库;
静态库制作完了,如何使用它内部的函数呢?只需要在使用到这些公用函数的源程序中包含
这些公用函数的原型声明,然后在用gcc命令生成目标文件时指明静态库名,gcc将会从静
态库中将公用函数连接到目标文件中。注意,gcc会在静态库名前加上前缀lib,然后追加扩
展名.a得到的静态库文件名来查找静态库文件。

在程序3:main.c中,我们包含了静态库的头文件hello.h,然后在主程序main中直接调用公
用函数hello。下面先生成目标程序hello,然后运行hello程序看看结果如何。

# gcc -o hello main.c -L. -lmyhello
# ./hello
Hello everyone!
#
我们删除静态库文件试试公用函数hello是否真的连接到目标文件 hello中了。
# rm libmyhello.a
rm: remove regular file `libmyhello.a'? y
# ./hello
Hello everyone!
#
程序照常运行,静态库中的公用函数已经连接到目标文件中了。
我们继续看看如何在Linux中创建动态库。我们还是从.o文件开始。
第5步:由.o文件创建动态库文件;
动态库文件名命名规范和静态库文件名命名规范类似,也是在动态库名增加前缀lib,但其
文件扩展名为.so。例如:我们将创建的动态库名为myhello,则动态库文件名就是
libmyhello.so。用gcc来创建动态库。

在系统提示符下键入以下命令得到动态库文件libmyhello.so。
# gcc -shared -fPCI -o libmyhello.so hello.o
#
我们照样使用ls命令看看动态库文件是否生成。
# ls
hello.c hello.h hello.o libmyhello.so main.c
#
第6步:在程序中使用动态库;
在程序中使用动态库和使用静态库完全一样,也是在使用到这些公用函数的源程序中包含这
些公用函数的原型声明,然后在用gcc命令生成目标文件时指明动态库名进行编译。我们先
运行gcc命令生成目标文件,再运行它看看结果。

# gcc -o hello main.c -L. -lmyhello
# ./hello
./hello: error while loading shared libraries: libmyhello.so: cannot open shared object file: No such
file or directory

#
哦!出错了。快看看错误提示,原来是找不到动态库文件libmyhello.so。程序在运行时,会
在/usr/lib和/lib等目录中查找需要的动态库文件。若找到,则载入动态库,否则将提示类似
上述错误而终止程序运行。我们将文件 libmyhello.so复制到目录/usr/lib中,再试试。

# mv libmyhello.so /usr/lib
# ./hello
Hello everyone!
#
成功了。这也进一步说明了动态库在程序运行时是需要的。
我们回过头看看,发现使用静态库和使用动态库编译成目标程序使用的gcc命令完全一样,
那当静态库和动态库同名时,gcc命令会使用哪个库文件呢?抱着对问题必究到底的心情,
来试试看。

先删除 除.c和.h外的 所有文件,恢复成我们刚刚编辑完举例程序状态。
# rm -f hello hello.o /usr/lib/libmyhello.so
# ls
hello.c hello.h main.c
#
在来创建静态库文件libmyhello.a和动态库文件libmyhello.so。
# gcc -c hello.c
# ar cr libmyhello.a hello.o
# gcc -shared -fPCI -o libmyhello.so hello.o
# ls
hello.c hello.h hello.o libmyhello.a libmyhello.so main.c
#
通过上述最后一条ls命令,可以发现静态库文件libmyhello.a和动态库文件libmyhello.so都
已经生成,并都在当前目录中。然后,我们运行gcc命令来使用函数库myhello生成目标文
件hello,并运行程序 hello。

# gcc -o hello main.c -L. -lmyhello
# ./hello
./hello: error while loading shared libraries: libmyhello.so: cannot open shared object file: No such
file or directory

#
从程序hello运行的结果中很容易知道,当静态库和动态库同名时, gcc命令将优先使用动
态库。

相关文档
最新文档