linux库文件编写入门 使用和生成库

转载 2012年03月29日 16:04:19

原文:

http://apps.hi.baidu.com/share/detail/49267951




一、为什么要使用库文件
 我们在实际编程工作中肯定会遇到这种情况:有几个项目里有一些函数模块的功能相同,
实现代码也相同,也是我们所说的重复代码。比如,很多项目里都有一个用户验证的功能。
代码段如下:
   //UserLogin.h文件,提供函数声明
   int IsValidUser(char* username, int namelen);
  
   //UserLogin.c文件,实现对用户信息的验证
   int  IsValidUser(char* username, int namelen)
   {
     int IsValid = 0;
     /*下面是具体的处理代码,略去*/
     return IsValid
   }
   如果每个项目都保存着这两个UserLogin.h和UserLogin.c文件,会有以下几个
弊端:
   1、每个项目里都有重复的模块,造成代码重复。  
   2、代码的重用性不好,一旦IsValidUser的代码发生了变化,为了保持设计的一致性,
我们还要手工修改其他项目里的 UserLogin.c文件,既费时又费力,还容易出错。  
库文件就是对公共代码的一种组织形式。 
    为了解决上面两个弊端,就提出了用库文件存放公共代码的解决方案,其要点就是
把公共的(也就是可以被多次复用的)目标代码从项目中分离出来,统一存放到库文件中,
项目要用到这些代码的时候,在编译或者运行的时候从库文件中取得目标代码即可。库文件
又分两种:静态库和动态库。

二、静态库与动态库
    如果程序是在编译时加载库文件的,就是使用了静态库。如果是在运行时加载目标代码,
就成为动态库。换句话说,如果是使用静态库,则静态库代码在编译时就拷贝到了程序的代码段,
程序的体积会膨胀。如果使用动态库,则程序中只保留库文件的名字和函数名,在运行时去查找
库文件和函数体,程序的体积基本变化不大。
    静态库的原则是“以空间换时间”,增加程序体积,减少运行时间;
    动态库则是“以时间换空间”,增加了运行时间,但减少了程序本身的体积。
    下面我们就以实际例子来看看如何使用这两种库.
 
三、静态库的编写和使用
1、概述
   静态库文件的扩展名一般为.a,其编写步骤很简单。
 ⑴编写函数代码
 ⑵编译生成各目标文件
 ⑶ 用ar文件对目标文件归档,生成静态库文件。
    注意归档文件名必须以lib打头。
   使用要点:
   ⑴在gcc 的-I参数后加上静态库头文件的路径。
   ⑵在gcc 的-L参数后加上库文件所在目录
   ⑶在gcc 的-l参数后加上库文件名,但是要去掉lib和.a扩展名。
     比如库文件名是libtest.a 那么参数就是 -l test
 
2、编写最简单的静态库文件
   编写如下两个文件,注意放在同一目录中
    myalib.h   //静态库头文件
    myalib.c   //静态库实现文件
   
    //myalib.h  文件的内容
 void test();
 
 //myalib.c  文件的内容
 #inlcude <stdio.h>
 void test()
 {
  printf("test\n");
 }
 
3、制作库文件
 ⑴ 生成目标文件
  gcc -c myalib.c
  执行完后会生成一个myalib.o文件
 ⑵用ar命令归档,格式为ar -rc <生成的档案文件名> <.o文件名列表>
 再次提醒,归档文件名一定要以lib打头, .a结尾。
  ar -rc libtest.a myalib.o
  执行完后会生成一个libtest.a文件
 
4、使用库文件 
 ⑴ 编写一个测试程序main.c,内容为
 //main.c 测试静态库调用的程序
 #include "myalib.h"   //要把函数的头文件包含进来,否则编译时会报错
  int main(int argc,char* argv[])
 {
  test();
  return 0;  
 }
 ⑵编译目标文件,注意要把静态库头文件的路径加到-I参数里面
   gcc -I /root/exercise -o main.o -c main.c
  现在生成了一个main.o文件
 ⑶生成可执行文件,注意要把静态库文件的路径加到 -L参数里面,
 把库文件名 (去掉打头的lib和结尾的.a)加到-l参数后面。如下面所示
  gcc -o main -L/root/exercise   main.o -ltest
  此时就会生成一个名为main的可执行文件
  另外,注意- l参数好象应该加到输入文件名的后面,否则会报错。
  比如gcc -o main -L/root/exercise   -ltest main.o就会提示
  main.o(.text+0x11): In function `main&apos;:
  : undefined reference to `test&apos;
  collect2: ld returned 1 exit status
  原因我还不清楚:-)
 ⑷执行可执行文件查看效果
  执行./main,  输出
  test
  说明执行成功。
  
四、动态库的编写
1、概述
   动态库一般以.so结尾,就是shared object的意思.
   其基本生成步骤为
   ⑴编写函数代码
   ⑵编译生成动态库文件,要加上 -shared 和 -fpic 选项 ,
     库文件名以lib开头, 以.so 结尾。
    
   使用方式分为两种: 隐式调用和显示调用 
    隐式调用类似于静态库的使用,但需修改动态链接库的配置文件/etc/ld.so.conf;
    显示调用则是在主程序里使用dlopen、dlsym、dlerror、dlclose等系统函数。
    具体的调用方式会在 "五、动态库的调用" 中详细说明.
2、编写最简单的动态库文件
   为了便于对照, 我们仍然采用静态库中的文件做例子.
    编写如下两个文件,注意放在同一目录中
    myalib.h   //静态库头文件
    myalib.c   //静态库实现文件
   
    //myalib.h  文件的内容
 void test();
 
 //myalib.c  文件的内容
 #inlcude <stdio.h>
 void test()
 {
  printf("test\n");
 }
 
3、编译生成动态库 ,库文件名以lib开头, 以.so 结尾。
 gcc -fpic -shared -o libtest.so  myalib.c
 此时就生成一个libtest.so文件
 
五、动态库的隐式调用
  隐式调用的含义是代码里不出现库文件名,就是说这个代码和
  调用静态库的代码是类似的。
1、编写测试文件
 //main.c 测试动态库隐式调用的程序
 #include "myalib.h"   //要把函数的头文件包含进来,否则编译时会报错
  int main(int argc,char* argv[])
 {
  test();
  return 0;  
 }

2、 编译测试程序,与静态库类似,要把头文件的路径加到-I参数里面
  gcc -I /root/exercise -o main.o -c main.c
  现在生成了一个main.o文件
3、连接生成测试程序 
  gcc -o main -L/root/exercise   main.o -ltest
  现在生成了一个main文件
4、执行测试程序
  ./main
  此时出现提示
    ./main: error while loading shared libraries: libtest.so: cannot open shared object file: No such file or directory。
    这个原因就是程序运行时并不知道动态库所在的路径,因此自然找不到。
    解决这个问题的办法有三种。见下节

六、使动态库被系统共享的三种办法
   (再次说明: 本节参考了计算机世界网雨亦奇的文章"LINUX动态链接库高级应用"
     地址http://www.ccw.com.cn/htm/center/prog/02_3_13_3_2.asp)   
(1)拷贝动态链接库到系统共享目录下,或在系统共享目录下为该动态链接库
   建立连接(硬连接或符号连接均可,常用符号连接).这里说的系统共享目录,
   指的是LINUX动态链接库存放的目录,包括
   /lib,/usr/lib以及/etc/ld.so.conf文件内所列的一系列目录.
  
   实例:执行
 # cp libtest.so /lib
 # ldconfig
 
  
  或:
  # ln -s `pwd`/libtest.so /lib
 # ldconfig
 
 注意pwd前后有两个反引号`,其目的是取得 pwd命令的输出,即当前目录.
 
 此时再执行main,即可成功.
 
(2)将动态链接库所在目录名追加到动态链接库配置文件/etc/ld.so.conf 中.
# pwd >> /etc/ld.so.conf
# ldconfig
 
 此时再执行main,即可成功.
 
(3)利用动态链接库管理命令ldconfig,强制其搜索指定目录,并更新缓存文件,便于动态装入.
 # ldconfig `pwd`
 
   此时再执行main,即可成功.
  
   要注意,第三种方法虽然有效,但效果是暂时的,供程序测试还可以,一旦再度运行ldconfig,
   则缓存文件内容可能改变,所需的动态链接库可能不被系统共享了.
   而且无论哪种办法,其实质都是用ldconfig命令把动态库文件
   所在路径加入到系统库列表中,(前两种永久,第三种临时)
   

七、动态库的显式调用
  显式调用的含义是代码出现库文件名,用户需要自己去
  打开和管理库文件。其要点为:
  ⑴把dlfcn.h系统头文件包含进来
  ⑵用dlopen函数打开库文件,并指定打开方式
 dllope的的第一个参数为共享库的名称,将会在下面位置查找指定的共享库。
  ①环境变量LD_LIBRARY_PATH列出的用分号间隔的所有目录。
  ②文件/etc/ld.so.cache 中找到的库的列表,由ldconfig命令刷新。
  ③目录usr/lib。
  ④目录/lib。
  ⑤当前目录。
 第二个参数为打开共享库的方式。有两个取值
  ①RTLD_NOW:将共享库中的所有函数加载到内存
  ②RTLD_LAZY:会推后共享库中的函数的加载操作,直到调用dlsym()时方加载某函数

  ⑶用dlerror()函数测试是否打开成功,并进行错误处理;
  ⑷用dlsym获得函数地址,存放在一个函数指针中
  ⑸用获得的函数指针进行函数调用。
  ⑹程序结束时用dlclose关闭打开的动态库,防止资源泄露。
  ⑺用ldconfig工具把动态库的路径加到系统库列表中
 
1、编写测试文件
 //main.c 测试动态库显式调用的程序
 #include<dlfcn.h>      //用于动态库管理的系统头文件  
 #include "myalib.h"    //要把函数的头文件包含进来,否则编译时会报错
  int main(int argc,char* argv[])
 {
   //声明对应的函数的函数指针
  void (*pTest)();   
      
         //加载动态库
  void *pdlHandle = dlopen("libtest.so", RTLD_LAZY); 
  
  //错误处理
        if(pdlHandle == NULL )    {
         printf("Failed load library\n");
         return -1;
     }
     char* pszErr = dlerror();
     if(pszErr != NULL)
     {
         printf("%s\n", pszErr);
         return -1;
     }
     
     //获取函数的地址
     pTest = dlsym(pdlHandle, "test");
     pszErr = dlerror();
     if(pszErr != NULL)
     {
         printf("%s\n", pszErr);
         dlclose(pdlHandle);
         return -1;
     }
     
     //实现函数调用
     (*pTest)();


  //程序结束时关闭动态库
  dlclose(pdlHandle);
  return 0;  
 } 
 
2、编译测试文件 使用-ldl选项指明生成的对象模块需要使用共享库
 gcc -o main -ldl main.c
 执行完后就生成了一个main文件

3、执行测试程序
 执行 ./main
 输出
    test
    说明成功。

六、使用动态库时应注意的其他问题
1、无论是动态库的显式调用还是隐式调用,都需要用
ldconfig工具将动态库的路径加到系统库列表中,否则运行时会出错。  
2、可以用ldd命令检查程序都使用到哪些共享库
 ldd命令行用法如下:
 ldd [--version] [-v|--verbose] [-d|--data-relocs] [-r|--function-relocs] [--help] FILE...
  各选项说明如下:
  (1) --version : 此选项用于打印出ldd的版本号.
  (2) -v 或 --verbose : 此选项指示ldd输出关于所依赖的动态链接库的尽可能详细的信息.
  (3) -d 或 --data-relocs : 此选项执行重定位,并且显示不存在的函数.
  (4) -r 或 --function-relocs : 此选项执行数据对象与函数的重定位,同时报告不存在的对象.
  (5) --help : 此选项用于打印出ldd的帮助信息.
  我们一般用-v选项.
  现在看几个实例
  ⑴用静态库连接时的结果  
 #ldd main
 libc.so.6 => /lib/tls/libc.so.6 (0xb74ad000)
 /lib/ld-linux.so.2 => /lib/ld-linux.so.2 (0xb75eb000)
 可见使用静态库时,由于库已经被编译成程序的一部分,因此ldd的输出中就只有用到的
 系统库。
 

 ⑵用动态库隐式连接时的结果
  libtest.so => /root/exercise/libtest.so (0xb75e2000)
     libc.so.6 => /lib/tls/libc.so.6 (0xb74ab000)
     /lib/ld-linux.so.2 => /lib/ld-linux.so.2 (0xb75eb000)
     可见隐式使用动态库时,所有用到的动态库(包括系统和用户的)都会被显示出来。
 

 ⑶动态库显式连接时的结果
 ldd main
 libdl.so.2 => /lib/libdl.so.2 (0xb75e1000)
    libc.so.6 => /lib/tls/libc.so.6 (0xb74aa000)
    /lib/ld-linux.so.2 => /lib/ld-linux.so.2 (0xb75eb000)
 可见显式使用动态库时,程序中不再保存运行时打开动态库的信息,只保留用到的系统库的信息.  
 这个与使用静态库时的输出是类似的.
 
------------------------------------------------------------------------------------------------

使用和生成库
基本概念

库有动态与静态两种,动态通常用.so为后缀,静态用.a为后缀。例如:libhello.so libhello.a

为了在同一系统中使用不同版本的库,可以在库文件名后加上版本号为后缀,例如: libhello.so.1.0, 由于程序连接默认以.so为文件后缀名。所以为了使用这些库,通常使用建立符号连接的方式。
ln -s libhello.so.1.0 libhello.so.1
ln -s libhello.so.1 libhello.so

使用库

当 要使用静态的程序库时,连接器会找出程序所需的函数,然后将它们拷贝到执行文件,由于这种拷贝是完整的,所以一旦连接成功,静态程序库也就不再需要了。然 而,对动态库而言,就不是这样。动态库会在执行程序内留下一个标记‘指明当程序执行时,首先必须载入这个库。由于动态库节省空间,linux下进行连接的 缺省操作是首先连接动态库,也就是说,如果同时存在静态和动态库,不特别指定的话,将与动态库相连接。
现在假设有一个叫hello的程序开发包,它提供一个静态库libhello.a 一个动态库libhello.so,一个头文件hello.h,头文件中提供 sayhello()这个函数
/* hello.h */
void sayhello();
另外还有一些说明文档。这一个典型的程序开发包结构
1.与动态库连接
linux默认的就是与动态库连接,下面这段程序testlib.c使用hello库中的sayhello()函数

/*testlib.c*/
#include <hello.h>
#include <stdio.h>

int main()
{
sayhello();
return 0;
}

使用如下命令进行编译
$gcc -c testlib.c -o testlib.o
用如下命令连接:
$gcc testlib.o -lhello -o testlib
在连接时要注意,假设libhello.o 和libhello.a都在缺省的库搜索路径下/usr/lib下,如果在其它位置要加上-L参数
与与静态库连接麻烦一些,主要是参数问题。还是上面的例子:
$gcc testlib.o -o testlib -WI,-Bstatic -lhello
注:这个特别的"-WI,-Bstatic"参数,实际上是传给了连接器ld.
指示它与静态库连接,如果系统中只有静态库当然就不需要这个参数了。
如果要和多个库相连接,而每个库的连接方式不一样,比如上面的程序既要和libhello进行静态连接,又要和libbye进行动态连接,其命令应为:
$gcc testlib.o -o testlib -WI,-Bstatic -lhello -WI,-Bdynamic -lbye
3.动态库的路径问题
为了让执行程序顺利找到动态库,有三种方法:
(1)把库拷贝到/usr/lib和/lib目录下。
(2)在 LD_LIBRARY_PATH环境变量中加上库所在路径。例如动态库libhello.so在/home/ting/lib目录下,以bash 为例,使用命令:
$export LD_LIBRARY_PATH=$LD_LIBRARY_PATH:/home/ting/lib
(3) 修改/etc/ld.so.conf文件,把库所在的路径加到文件末尾,并执行ldconfig刷新。这样,加入的目录下的所有库文件都可见、

4.查看库中的符号
有 时候可能需要查看一个库中到底有哪些函数,nm命令可以打印出库中的涉及到的所有符号。库既可以是静态的也可以是动态的。nm列出的符号有很多,常见的有 三种,一种是在库中被调用,但并没有在库中定义(表明需要其他库支持),用U表示;一种是库中定义的函数,用T表示,这是最常见的;另外一种是所谓的“弱 态”符号,它们虽然在库中被定义,但是可能被其他库中的同名符号覆盖,用W表示。例如,假设开发者希望知道上央提到的hello库中是否定义了 printf():
$nm libhello.so |grep printf
U printf
U表示符号printf 被引用,但是并没有在函数内定义,由此可以推断,要正常使用hello库,必须有其它库支持,再使用ldd命令查看hello依赖于哪些库:
$ldd hello
libc.so.6=>/lib/libc.so.6(0x400la000)
/lib/ld-linux.so.2=>/lib/ld-linux.so.2 (0x40000000)
从上面的结果可以继续查看printf最终在哪里被定义,有兴趣可以go on


生成库

第一步要把源代码编绎成目标代码。以下面的代码为例,生成上面用到的hello库:
/* hello.c */
#include <stdio.h>
void sayhello()
{
printf("hello,world\n");
}
用gcc编绎该文件,在编绎时可以使用任何全法的编绎参数,例如-g加入调试代码等:
gcc -c hello.c -o hello.o

1. 连接成静态库
连接成静态库使用ar命令,其实ar是archive的意思
$ar cqs libhello.a hello.o
2. 连接成动态库
生成动态库用gcc来完成,由于可能存在多个版本,因此通常指定版本号:
$gcc -shared -Wl,-soname,libhello.so.1 -o libhello.so.1.0 hello.o
另外再建立两个符号连接:
$ln -s libhello.so.1.0 libhello.so.1
$ln -s libhello.so.1 libhello.so
这样一个libhello的动态连接库就生成了。最重要的是传gcc -shared 参数使其生成是动态库而不是普通执行程序。
-Wl 表示后面的参数也就是-soname,libhello.so.1直接传给连接器ld进行处理。实际上,每一个库都有一个soname,当连接器发现它正 在查找的程序库中有这样一个名称,连接器便会将soname嵌入连结中的二进制文件内,而不是它正在运行的实际文件名,在程序执行期间,程序会查找拥有 soname名字的文件,而不是库的文件名,换句话说,soname是库的区分标志。
这样做的目的主要是允许系统中多个版本的库文件共存,习惯上在命名库文件的时候通常与soname相同
libxxxx.so.major.minor
其中,xxxx 是库的名字,major是主版本号,minor 是次版本号

相关文章推荐

linux库文件编写入门 .

linux库文件的编写 作者: laomai 地址: http://blog.csdn.net/laomai 本文主要参考了如下资料 ⑴hcj写的"Linux静态/动态链接库的创建和使用" ...

linux 库文件 生成与使用

linux 库文件 生成与使用 分类: 程序语言 linux 2008-11-17 19:08 1506人阅读 评论(0) 收藏 举报 1、linux库文件分为静态库和动态...
  • lionzl
  • lionzl
  • 2011年11月01日 14:27
  • 254

Linux c++ 生成和使用链接库文件

1. 静态链接库  静态库是obj文件的集合,一般以“.a”为后缀。静态库的有点事可以不用重新编译源程序,直接进行程序的重新链接,节省编译时间。开发者可以提供库文件而不用开放源代码。   命令: ...

LINUX库文件的生成与使用

1、linux库文件分为静态库和动态库两种。静态库习惯以.a 结尾,而动态库习惯以.so(shared object)结尾。而且必须以lib开头。2、静态库的原则是“以空间换时间”,增加程序体积,减少...

linux库文件生成与使用

1、linux库文件分为静态库和动态库两种。静态库习惯以.a 结尾,而动态库习惯以.so(shared object)结尾。而且必须以lib开头。 2、静态库的原则是“以空间换时间”,增加程...

Linux入门之库文件

最近着手学习Linux的基本命令和操作,刚刚接触库文件,先来说两句。 一、概念 1. 库文件:库是一组预先编译好的函数集合,实现了程序上共享代码的功能,通常由一组相关关联的函数组成。         ...

linux .c文件生成库文件的方法与使用

1、linux库文件分为静态库和动态库两种。静态库习惯以.a 结尾,而动态库习惯以.so(shared object)结尾。而且必须以lib开头。 2、静态库的原则是“以空间换时间”,增加程序体...

Android 第三方库使用实例——编写.so库文件

环境: 1. win7 64位系统 2. Android NDK ,Cygwin,CDT, Sequoyyah,JNI 安装正确 这两天一直在弄Android的Jni调用第三方库,网上有很多教程是...

【Visual Studio】使用 pexports 根据 VS 的 .dll 动态链接库生成 .lib 库文件

一、问题描述: 最近博主需要使用 8 路 USB 视频采集卡做二次开发,最后选择一款叫做“中维世纪”的 8 路 USB 视频采集卡 C301。但是,官网上仅提供了 1.0.0.4 版本的 SDK,使用...

Android NDK入门实例 计算斐波那契数列二生成.so库文件

上一篇文章输生成了jni头文件,里面包含了本地C代码的信息,提供我们引用的C头文件。下面实现本地代码,再用ndk-build编译生成.so库文件。由于编译时要用到make和gcc,这里很多人是通过安装...
内容举报
返回顶部
收藏助手
不良信息举报
您举报文章:linux库文件编写入门 使用和生成库
举报原因:
原因补充:

(最多只允许输入30个字)