GCC编译动态和静态链接库-五星文库
免费文档下载
GCC编译动态和静态链接库
导读：函数库分为静态库和动态库两种，静态库在程序编译时会被连接到目标代码中，程序运行时将不再需要该静态库，动态库在程序编译时并不会被连接到目标代码中，因此在程序运行时还需要动态库存在，本文主要通过举例来说明在Linux中如何创建静态库和动态库，并将函数库的源程序编译成.o文件，第2步：将hello.c编译成.o文件，无论静态库，还是动态库，我们必须将源程序hello.c通过gcc先编译成.o文件，下
我们通常把一些公用函数制作成函数库，供其它程序使用。函数库分为静态库和动态库两种。静态库在程序编译时会被连接到目标代码中，程序运行时将不再需要该静态库。动态库在程序编译时并不会被连接到目标代码中，而是在程序运行是才被载入，因此在程序运行时还需要动态库存在。本文主要通过举例来说明在Linux中如何创建静态库和动态库，以及使用它们。
在创建函数库前，我们先来准备举例用的源程序，并将函数库的源程序编译成.o文件。
第1步：编辑得到举例的程序--hello.h、hello.c和main.c；
hello.c(见程序2)是函数库的源程序，其中包含公用函数hello，该函数将在屏幕上输出&Hello XXX!&。hello.h(见程序1)为该函数库的头文件。main.c(见程序3)为测试库文件的主程序，在主程序中调用了公用函数hello。
6. #ifndef HELLO_H #define HELLO_H
void hello(const char *name);
#endif //HELLO_H
程序1: hello.h
6. #include &stdio.h&
void hello(const char *name) { printf(&Hello %s!\n&, name); }
程序2: hello.c
7. #include &hello.h&
int main() { hello(&everyone&); return 0; }
程序3: main.c
第2步：将hello.c编译成.o文件；
无论静态库，还是动态库，都是由.o文件创建的。因此，我们必须将源程序hello.c通过g cc先编译成.o文件。
在系统提示符下键入以下命令得到hello.o文件。
# gcc -c hello.c
我们运行ls命令看看是否生存了hello.o文件。
hello.c hello.h hello.o main.c
在ls命令结果中，我们看到了hello.o文件，本步操作完成。
下面我们先来看看如何创建静态库，以及使用它。
第3步：由.o文件创建静态库；
静态库文件名的命名规范是以lib为前缀，紧接着跟静态库名，扩展名为.a。例如：我们将创建的静态库名为myhello，则静态库文件名就是libmyhello.a。在创建和使用静态库时，需要注意这点。创建静态库用ar命令。
在系统提示符下键入以下命令将创建静态库文件libmyhello.a。
# ar crv libmyhello.a hello.o
我们同样运行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??)
#gcc main.c libmyhello.a -o main
Hello everyone!
我们删除静态库文件试试公用函数hello是否真的连接到目标文件 hello中了。
# rm libmyhello.a
rm: remove regular file `libmyhello.a'? y
Hello everyone!
程序照常运行，静态库中的公用函数已经连接到目标文件中了。
我们继续看看如何在Linux中创建动态库。我们还是从.o文件开始。
第5步：由.o文件创建动态库文件；
动态库文件名命名规范和静态库文件名命名规范类似，也是在动态库名增加前缀lib，但其文件扩展名为.so。例如：我们将创建的动态库名为myhello，则动态库文件名就是libmyhello.so。用gcc来创建动态库。
在系统提示符下键入以下命令得到动态库文件libmyhello.so。
# gcc -shared -fPCI -o libmyhello.so hello.o
我们照样使用ls命令看看动态库文件是否生成。
hello.c hello.h hello.o libmyhello.so main.c
第6步：在程序中使用动态库；
在程序中使用动态库和使用静态库完全一样，也是在使用到这些公用函数的源程序中包含这些公用函数的原型声明，然后在用gcc命令生成目标文件时指明动态库名进行编译。我们先
运行gcc命令生成目标文件，再运行它看看结果。
# gcc -o hello main.c -L. -lmyhello
./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 everyone!
成功了。这也进一步说明了动态库在程序运行时是需要的。
我们回过头看看，发现使用静态库和使用动态库编译成目标程序使用的gcc命令完全一样，那当静态库和动态库同名时，gcc命令会使用哪个库文件呢？抱着对问题必究到底的心情，来试试看。
先删除除.c和.h外的所有文件，恢复成我们刚刚编辑完举例程序状态。
# rm -f hello hello.o /usr/lib/libmyhello.so
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
hello.c hello.h hello.o libmyhello.a libmyhello.so main.c
通过上述最后一条ls命令，可以发现静态库文件libmyhello.a和动态库文件libmyhello.so都已经生成，并都在当前目录中。然后，我们运行gcc命令来使用函数库myhello生成目标文件hello，并运行程序 hello。
包含总结汇报、外语学习、文档下载、教学研究、办公文档、旅游景点、IT计算机、资格考试、word文档以及GCC编译动态和静态链接库等内容。本文共2页
相关内容搜索gcc编译链接动态库详解
gcc编译链接动态库详解
比较详细的介绍了gcc编译链接动态库的原理。
一、GNU gcc的编译工具用法
我们先来写一个简单的C程序：hello.c
1. #include &stdio.h&
3. void print_hello() {
4. printf(&Hello World/n&);
7. int main(int argc, char argv[]) {
8. print_hello();
9. return 0;
定义了一个print_hello函数，调用main函数打印Hello World。
如何编译它呢？
1. gcc -o hello -O2 hello.c
-o参数指定生成的可执行程序的文件名， -O2是优化级别。该命令会编译生成hello可执行程序，看看这个文件：ls -l hello
C代码 复制代码
1. -rwxr-xr-x 1 robbin users -11-02 13:48 hello
有11KB大小。
看看他链接了哪些系统动态链接库，用ldd命令：
1. ldd hello
输出信息为：
1. libc.so.6 =& /lib64/tls/libc.so.6 (0x6d000)
2. /lib64/ld-linux-x86-64.so.2 (0x56000)
libc是C语言标准函数库，ld是动态链接器。
接着我们看看hello这个程序里面有哪些符号，用nm命令：
1. nm hello
1. 08f8 A __bss_start
2. 043c t call_gmon_start
4. 04f0 T main
5. 0658 d p.0
6. 04e0 T print_hello
7. U puts@@GLIBC_2.2.5
8. 0410 T _start
中间省略了一些，不过我们还是可以在符号表里面找到函数定义。
hello有11KB，体积偏大，去处符号表可以给它瘦身，我们用strip命令：
1. strip hello
然后再ls -l hello，输出为：
1. -rwxr-xr-x 1 webuser users -02 13:56 hello
只有4.4KB了，瘦身效果明显！ 不过这次符号表再也看不到了，nm hello，输出为：nm: hello: no symbols。
最后如果我们想从可执行程序里面提取出来一点什么文本信息的话，还可以用strings命令：
1. strings hello
输出信息为：
1. /lib64/ld-linux-x86-64.so.2
3. libc.so.6
5. __libc_start_main
6. __gmon_start__
7. GLIBC_2.2.5
9. Hello World
友情提醒一下，如果你用Java写一个HelloWorld.java，编译以后你也可以用strings窥探一番。
二、动态共享库怎么使用
这次我们把hello.c拆开成为两个文件：hello.c和main.c。hello.c的代码是：
1. #include &stdio.h&
3. void print_hello() {
4. printf(&Hello World/n&);
而main.c的代码是：
1. int main(int argc, char argv[]) {
2. print_hello();
3. return 0;
hello.c是我们的动态共享库，在hello.c里面我们声明和实现了各种公用的函数，最后main.c可以去调用这些公用函数。首先我们要把hello.c编译成为动态共享库：
C代码 复制代码
1. gcc -o libhello.so -O2 -fPIC -shared hello.c
-fPIC参数声明链接库的代码段是可以共享的，-shared参数声明编译为共享库。请注意这次我们编译的共享库的名字叫做libhello.so，这也是Linux共享库的一个命名的惯例了：后缀使用so，而名称使用libxxxx格式。
然后编译main.c的时候，我们需要更多的参数让gcc知道如何寻找共享库：
1. gcc -o main -O2 -L. -lhello main.c
-L参数指定到哪个附加路径下面去寻找共享库，现在我们指定在当前目录下面寻找；
-l (L的小写字母)参数指定链接到哪个共享库上面，我们传的参数hello，那么gcc就会自动链接到libhello.so这个共享库上面(注意我们上面说的libXXXX.so命名规则)；
-I ( i 的大写字母)参数指定到哪个附加路径下面去寻找h文件，这个我们没有使用。
最后我们成功编译好了main，执行一下，报错：
./main: error while loading shared libraries: libhello.so: cannot open shared object file: No such file or directory
找不到libhello.so这个共享库，怎么回事？这是因为libhello.so并不在操作系统默认的共享库的路径下面，我们可以临时指定一下
链接路径：
1. export LD_LIBRARY_PATH=.:$LD_LIBRARY_PATH
这样就成功了。我们用ldd main看一下：
1. libhello.so =& ./libhello.so (0x6d000)
2. libc.so.6 =& /lib64/tls/libc.so.6 (0x6e000)
3. /lib64/ld-linux-x86-64.so.2 (0x56000)
这次main程序链接到了libhello.so这个共享库上面。
三、关于Linux的动态共享库的设置
可执行程序找不到要链接的动态共享库，这是Linux上面编译和运行程序很容易碰到的问题，通过上面的小例子，我们已经大致了解共享库的一点基本原理，接下来我们要探讨一下怎么设置程序寻找动态共享库的行为。
Linux操作系统上面的动态共享库大致分为三类：
1、操作系统级别的共享库和基础的系统工具库
比方说libc.so, libz.so, libpthread.so等等，这些系统库会被放在/lib和/usr/lib目录下面，如果是64位操作系统，还会有/lib64和/usr /lib64目录。如果操作系统带有图形界面，那么还会有/usr/X11R6/lib目录，如果是64位操作系统，还有/usr/X11R6 /lib64目录。此外还可能有其他特定Linux版本的系统库目录。这些系统库文件的完整和版本的正确，确保了Linux上面各种程序能够正常的运行。
2、应用程序级别的系统共享库
并非操作系统自带，但是可能被很多应用程序所共享的库，一般会被放在/usr/local/lib和/usr/local/lib64这两个目录下面。很多你自行编译安装的程序都会在编译的时候自动把/usr/local/lib加入gcc的-L参数，而在运行的时候自动到/usr/local/lib下面去寻找共享库。
以上两类的动态共享库，应用程序会自动寻找到他们，并不需要你额外的设置和担心。这是为什么呢？因为以上这些目录默认就被加入到动态链接程序的搜索路径里面了。Linux的系统共享库搜索路径定义在/etc/ld.so.conf这个配置文件里面。这个文件的内容格式
大致如下：
1. /usr/X11R6/lib64
2. /usr/X11R6/lib
3. /usr/local/lib
6. /usr/lib64
7. /usr/lib
8. /usr/local/lib64
9. /usr/local/ImageMagick/lib
假设我们自己编译安装的ImageMagick图形库在/usr/local/ImageMagick目录下面，并且希望其他应用程序都可以使用ImageMagick的动态共享库，那么我们只需要把/usr/local/ImageMagick/lib目录加入/etc /ld.so.conf文件里面，然后执行：ldconfig 命令即可。
ldcofig将搜索以上所有的目录，为共享库建立一个缓存文件/etc/ld.so.cache。为了确认ldconfig已经搜索到ImageMagick的库，我们可以用上面介绍的strings命令从ld.so.cache里面抽取文本信息来检查一下：
1. strings /etc/ld.so.cache | grep ImageMagick
输出结果为：
1. /usr/local/ImageMagick/lib/libWand.so.10
2. /usr/local/ImageMagick/lib/libWand.so
3. /usr/local/ImageMagick/lib/libMagick.so.10
4. /usr/local/ImageMagick/lib/libMagick.so
5. /usr/local/ImageMagick/lib/libMagick++.so.10
6. /usr/local/ImageMagick/lib/libMagick++.so
已经成功了！
3、应用程序独享的动态共享库
有很多共享库只被特定的应用程序使用，那么就没有必要加入系统库路径，以免应用程序的共享库之间发生版本冲突。因此Linux还可以通过设置环境变量 LD_LIBRARY_PATH来临时指定应用程序的共享库搜索路径，就像我们上面举的那个例子一样，我们可以在应用程序的启动脚本里面预先设置 LD_LIBRARY_PATH，指定本应用程序附加的共享库搜索路径，从而让应用程序找到它。
具体如下：
（1）新建自己的头文件路径/home/user/workspace/include和库文件路径/home/user/workspace/lib，这两个目录用来存放我自己编写的头文件和库文件；
（2）接下来写个头文件和库文件作测试，在/home/user/workspace/include下新建文件test.h，在/home/user/workspace/lib下新建test.c，test.h中是一些函数原型，test.c是函数的实现；
（3）通过命令gcc -fPIC -shared -o libtest.so test.c在/home/user/workspace/lib生成了一个动态链接库文件libtest.so；
（4）现在把库文件路径添加进.bash_profile文件，添加内容如下：
C_INCLUDE_PATH=/home/cheney/workspace/include
export C_INCLUDE_PATH
LD_LIBRARY_PATH=/home/cheney/workspace/lib
export LD_LIBRARY_PATH
然后通过source .bash_profile把.bash_profile文件即时更新了。
我的热门文章
即使是一小步也想与你分享温馨提示！由于新浪微博认证机制调整，您的新浪微博帐号绑定已过期，请重新绑定！&&|&&
LOFTER精选
网易考拉推荐
用微信&&“扫一扫”
将文章分享到朋友圈。
用易信&&“扫一扫”
将文章分享到朋友圈。
阅读(9074)|
用微信&&“扫一扫”
将文章分享到朋友圈。
用易信&&“扫一扫”
将文章分享到朋友圈。
历史上的今天
loftPermalink:'',
id:'fks_',
blogTitle:'linux 生成和使用动态链接库和静态链接库的Makefile编写',
blogAbstract:'生成和使用动态链接库和静态链接库的Makefile编写\r\n1. 概述\r\n介绍linux下生成和使用动态链接库和静态链接库的Makefile的编写方法。\r\n&\r\n2. 生成动态链接库的Makefile\r\n\r\n首先要有一个c或c++等工具编写出来的库函数文件，也就是里面写了一堆可以被别的函数调用的函数。比如：\r\n&\r\naaa.cpp\r\n#include\r\n&stdio.h&\r\nvoid pf1(void)\r\n{\r\n\r\n&&&\r\nprintf(“********\\n”);\r\n\r\n&&&\r\n}\r\n',
blogTag:'',
blogUrl:'blog/static/',
isPublished:1,
istop:false,
modifyTime:0,
publishTime:5,
permalink:'blog/static/',
commentCount:0,
mainCommentCount:0,
recommendCount:0,
bsrk:-100,
publisherId:0,
recomBlogHome:false,
currentRecomBlog:false,
attachmentsFileIds:[],
groupInfo:{},
friendstatus:'none',
followstatus:'unFollow',
pubSucc:'',
visitorProvince:'',
visitorCity:'',
visitorNewUser:false,
postAddInfo:{},
mset:'000',
remindgoodnightblog:false,
isBlackVisitor:false,
isShowYodaoAd:false,
hostIntro:'',
hmcon:'1',
selfRecomBlogCount:'0',
lofter_single:''
{list a as x}
{if x.moveFrom=='wap'}
{elseif x.moveFrom=='iphone'}
{elseif x.moveFrom=='android'}
{elseif x.moveFrom=='mobile'}
${a.selfIntro|escape}{if great260}${suplement}{/if}
{list a as x}
推荐过这篇日志的人：
{list a as x}
{if !!b&&b.length>0}
他们还推荐了：
{list b as y}
转载记录：
{list d as x}
{list a as x}
{list a as x}
{list a as x}
{list a as x}
{if x_index>4}{break}{/if}
${fn2(x.publishTime,'yyyy-MM-dd HH:mm:ss')}
{list a as x}
{if !!(blogDetail.preBlogPermalink)}
{if !!(blogDetail.nextBlogPermalink)}
{list a as x}
{if defined('newslist')&&newslist.length>0}
{list newslist as x}
{if x_index>7}{break}{/if}
{list a as x}
{var first_option =}
{list x.voteDetailList as voteToOption}
{if voteToOption==1}
{if first_option==false},{/if}&&“${b[voteToOption_index]}”&&
{if (x.role!="-1") },“我是${c[x.role]}”&&{/if}
&&&&&&&&${fn1(x.voteTime)}
{if x.userName==''}{/if}
网易公司版权所有&&
{list x.l as y}
{if defined('wl')}
{list wl as x}{/list}gcc 混合连接动态库和静态库gcc 同时连接 静态库和动态库现在有 libmy.a & libmy.so两个库,其中的函数供main.cc调用要在可执行文件中同时连接这两个库gcc -g -lstdc++ -g -L.-lmy -l ./libmy.a -o test.exe main.cc // 报找不到libmy.a,可是在当前目录下已经有这个文件了gcc -g -lstdc++ -g -L.-l libmy.so -l ./libmy.a -o test.exe main.cc // 报找不到libmy.so,在当前目录下也有这个文件用了 -static 选线,则报动态库中的函数没定义请问大家有什么招不?感激
我记得静态库混合动态库要加特殊指令的,你可以试试这样：gcc -g -lstdc++ -g -WI,-Bdynamic -L.-lmy -WI,-Bstatic -L.-lmy -o test.exe main.cc
为您推荐：
其他类似问题
扫描下载二维码博客访问： 495100
博文数量： 114
博客积分： 766
博客等级： 军士长
技术积分： 1897
注册时间：
IT168企业级官微
微信号：IT168qiye
系统架构师大会
微信号：SACC2013
分类： C/C++
&&&&&&& 通常使用自己生成动态或静态库有三种方法，一是将库路径放在/etc/ld.conf相关的文件当中，一是通过修改LD_LIBRARY_PATH，最后还有种方法是用-L -l指定路径。&&&&&&& 今天将这几种方式用了下，发现没有LD_LIBRARY_PATH这个环境变量，另外文件到ld.conf当中也没用，所以在以后就用-L -l的方法了，-L是指定你的库路径，-l是指定你库的名字。&&&&&&& 还有一种情况需要注意，为了加快动态链接的速度，链接器通常会在ld.so.cache当中寻找，而忽视参数，这个时候需要执行/sbin/ldconfig来更新cache.&&&&&&&& 动态链接与运行加载描述的是同一件事情，动态链接指在编译的时候告诉gcc需要什么动态链接库，而运行加载则是告诉链接器链接动态库的路径，在一个完整的系统上两个有同样的效果,但使用的时间不同，同时这种做法也使得开发变得十分灵活，在编译链接时用-L,-l来指定所需的库，而在运行加载时在通过LDFLAGS来指定运行加载库，这样看来其实一个简单的动态库中间的过程也非常多，用法如下：编译：gcc&& xxx -L xx -lxx运行时：xxx -L -l (同时可以告诉链接器来完成LDFLAGS="Wl,rpath,xxx")&&&&&&& 关于静态链接和动态链接，有一种说法是错误的，即动态链接使用动态库，静态链接使用静态库，看起来像是这样的，但实际上不是的，静态链接是与动态链接的区别在于，前者在编译链接的时候，所有的库都已经放到可执行文件当中去了，而后者是值在运行时才将库加载内存当中去运行（链接时必须指明位置），而后者使用库的方式有两种方式，一种是静态库，另外一种是共享库，静态库和共享库（通常描述为动态库）的区别在与各个进程之间能否共享这个库，为什么这么说？那是因为静态库在链接生成可执行文件的时候在内存当中存放的位置就已经定死了，而共享库的位置却是通过指针来指向的，这样多个进程就可以指向存放在内存当中的同一个共享库了，可以通过反汇编的证实。另外他们还有一个区别，那就是在动态链接的时候最终会调用动态连接器来完成这个事情，然后在返回到源程序。&&&&&&
阅读(2495) | 评论(0) | 转发(1) |
相关热门文章
给主人留下些什么吧！~~
请登录后评论。