linux 动态库 例程
//////////////////////////////////// main.c ////////////////////////////////////////////////// #include
#include
#include "str_out.h"
//gcc main.c -o main -ldl
int main()
{
typedef void (*STROUT)(const char *);
void *hDynamicLib = NULL;
STROUT fpStrOut = NULL;
hDynamicLib = dlopen("./libStr.so",RTLD_LAZY);
if(hDynamicLib != NULL)
{
fpStrOut = (STROUT)dlsym(hDynamicLib,"str_out");
char *szErrInfo = dlerror();
if(szErrInfo == NULL)
{
fpStrOut("You are success again !\n");
}
else
{
printf("%s\n", szErrInfo);
}
dlclose(hDynamicLib);
}
else
{
printf("error: load dynamic library failed!\n");
}
return 0 ;
}
///////////////////////////// srt_out.h /////////////////////////////////////////////////
#ifndef _STR_OUT_H_
#define _STR_OUT_H_
void str_out(const char* str);
#endif
//////////////////////////// srt_out.c /////////////////////////////////////////
#include
#include "str_out.h"
//gcc srt_out.c -shared -fpic -o libStr.so
void str_out(const char * str)
{
printf("%s\n", str);
printf("hello\n ");
}
////////////////////////////////////////////////////////////////////////////////
GCC编译动态和静态链接库
我们通常把一些公用函数制作成函数库，供其它程序使用。函数库分为静态库和动态库两种。静态库在程序编译时会被连接到目标代码中，程序运行时将不再需要该静态库。动态库在程序编译时并不会被连接到目标代码中，而是在程序运行是才被载入，因此在程序运行时还需要动态库存在。本文主要通过举例来说明在Linux中如何创建静态库和动态库，以及使用它们。 在创建函数库前，我们先来准备举例用的源程序，并将函数库的源程序编译成.o文件。 第1步：编辑得到举例的程序--hello.h、hello.c和main.c； hello.c(见程序2)是函数库的源程序，其中包含公用函数hello，该函数将在屏幕上输出"Hello XXX!"。hello.h(见程序1)为该函数库的头文件。main.c(见程序3)为测试库文件的主程序，在主程序中调用了公用函数hello。 1.#ifndef HELLO_H 2.#define HELLO_H 3. 4.void hello(const char *name); 5. 6.#endif //HELLO_H 复制代码 程序1: hello.h 1.#include
第2步：将hello.c编译成.o文件； 无论静态库，还是动态库，都是由.o文件创建的。因此，我们必须将源程序hello.c通过g cc先编译成.o文件。 在系统提示符下键入以下命令得到hello.o文件。 # gcc -c hello.c # 我们运行ls命令看看是否生存了hello.o文件。 # ls 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命令查看结果： # ls hello.c hello.h hello.o libmyhello.a main.c # ls命令结果中有libmyhello.a。 第4步：在程序中使用静态库； 静态库制作完了，如何使用它内部的函数呢？只需要在使用到这些公用函数的源程序中包含这些公用函数的原型声明，然后在用gcc命令生成目标文件时指明静态库名，gcc将会从静态库中将公用函数连接到目标文件中。注意，gcc会在静态库名前加上前缀lib，然后追加
FORTRAN静态库动态库的生成
FORTRAN静态库、动态库的生成、维护与调用 闫昊明2006-9-10 一、FORTRAN静态库的生成与维护 FORTRAN 静态库是经过编译的代码块，它与主程序相对独立，可以被主程序调用，是FORTRAN工程类型之一. 静态库包含一系列子程序，但不包括主程序. 静态库一般具有LIB扩展名并包含目标代码，且静态库存放在它们特定的目录中. FORTRAN静态库在组织大型程序和在不同程序之间共享子程序等方面具有较大的优点，其重要性不言而喻. 当将静态库与主程序联系起来时，在主程序中调用静态库中的任何子程序将编译到相应的可执行程序. 应用静态库的时候，只有所需要的子程序才在编译过程中插入到可执行文件（.EXE）,这意味着这种可执行文件将比包含所有的子程序所生成的可执行文件小. 而且，不必担心哪些子程序是需要的，哪些是不需要的，编译器将替你做出选择. 同时，当更改静态库中的子程序时，相应的应用程序可以不做任何改变，而只需要对其进行重新的编译链接，即可获得新的结果，这无疑也是方便的. 目前，常用的FORTRAN静态库有很多种，WINDOWS操作系统下的Compaq Visual FORTRAN version 6.5（简称CVF65）自带的数学统计库IMSL就是一个非常全面的静态库，可以用来解决线性代数和统计学上的很多经典问题. 此外，在NCAR互联网站有很多有用的FORTRAN子程序（网址：https://www.wendangku.net/doc/d513721436.html,/softlib/mathlib.html），其中包括地球物理科学问题、离散和快速Fourier变换、可分离的椭圆微分方程、插值、Legendre多项式、普通数学问题、本征值问题求解、线性方程求解、非线性方程求解、常微分方程求解、特殊函数、统计学等常用子程序集等. 这些FORTRAN子程序可以解决很多基础性的问题，因此有很高的利用价值. 在WINDOWS操作系统下，可以用两个命令分别生成静态库. 一个是用‘nmake’命令，它一般用来编译原来应用在UNIX环境下的FORTRAN子程序集，在编译过程中要读取makefile文件中的编译命令，类似于在UNIX下安装软件. 另一个是用‘lib’命令，它可以在WINDOWS环境下编译任何需要集成为静态库的子程序集. 编译静态库在DOS命令行环境下比较方便，以后的命令行都指在此环境下运行. 在编译静态库前，首先要安装CVF65，其次要完成要编译的FORTRAN子程序(*.f90). 对于FORTRAN子程序，最好用FORTRAN90的标准来完成，应该放弃FORTRAN77标准。FORTRAN90是FORTRAN语言从结构化走向面向对象化的重要一步，使FORTRAN语言更加接近C＋＋。在FORTRAN90标准中，对数组的操作既增强了功能又简化了使用，此外自由格式、MODULE、动态数组、指针等的应用大大丰富了FORTRAN语言，使得编程更加轻松。目前，FORTRAN95和FORTRAN2000标准也在应用，它们与FORTRAN90标准比较类似，主要的改进在并行运算方面，因此目前在单机上应用的主要还是FORTRAN90. 在DOS命令行环境下，进入到FORTRAN子程序所在的子目录，然后按下面两个步骤生成FORTRAN静态库. （1）键入“df *.f90 /c”，回车，可以看到CVF65编译器对所有的FORTRAN子程序（*.f90）进行编译，生成*.obj文件（注意，编译时，/c中的“c”必须小写）. （2）键入“lib *.obj /out:libname.lib”，回车，可以看到链接生成libname.lib静态库. 需要注意的是，每次加入新的子程序或对静态库中的子程序修改以后，都要按上述两个步骤重新进行编译链接. 生成静态库以后，可用“dumpbin /linkermember libname.lib”来查看静态库中可用的子程序名称. 也可执行“lib /list libname.lib”来查看静态库中的*.obj文件. 当然，也可以在CVF65集成环境下，生成静态库. 步骤如下：
编译生成动态库时,被关联的静态库会被编译到动态库里面
动态库调用静态库. 生成动态库: 需要的目标文件得用-fPIC选项生成. 而静态库所需的目标文件可以不用-fPIC选项. 一个应用程序调用动态库, 而这个动态库其中的函数调用某静态库时,如何生成应用程序呢? 例: /////// static.h void static_print(); ///////static.cpp #include
C语言程序静态库和动态库的创建及其应用
C语言程序静态库和动态库的创建及其应用 在用c写程序时，很多时候需要存储一些简单的数据，如果为此而用mysql数据库就有些大才小用了，可以把这些数据以结构的形写入文件，然后再需要时读取文件，取出数据。 如下是定义函数的源文件和头文件： 源文件struct.c: #include "struct.h" //第一个参数是要写入的文件名，第二个参数是缓冲区，第三个参数是缓冲区大小，第四个参数是打开文件流的形态，返回TRUE表示写入成功，返回FALSE表示写入失败int writeStruct(const char *fileName,char *buffer,int bufferLen,char *mode){ int ret; FILE *fileID = NULL; fileID = fopen(fileName,mode); if (fileID == NULL){ perror("fopen"); goto writeEnd; } rewind(fileID); ret = fwrite(buffer,bufferLen,1,fileID); if (ret <= 0){ perror("fwrite"); goto writeEnd; } if (fileID != NULL){ fclose(fileID); fileID = NULL; } return TRUE;
writeEnd: if (fileID != NULL){ fclose(fileID); fileID = NULL; } return FALSE; } //第一个参数是要读取的文件名，第二个参数是缓冲区，第三个参数是缓冲区大小，第四个参数是打开文件流的形态，返回TRUE表示读取成功，返回FALSE表示读取失败int readStruct(const char *fileName,char *buffer,int bufferLen,char *mode){ int ret; FILE *fileID = NULL; fileID = fopen(fileName,mode); if (fileID == NULL){ perror("fopen"); goto readEnd; } rewind(fileID); memset(buffer,0,sizeof(buffer)); ret = fread(buffer,bufferLen,1,fileID); if (ret >= 0){ strcat(buffer,"\0"); }else{ perror("fread") ; goto readEnd; } if (fileID != NULL){ fclose(fileID); fileID = NULL; }
使用Automake生成Makefile及动态库和静态库的创建
使用Automake生成Makefile及动态库和静态库的创建使用Automake 创建和使用静态库 1. 目录结构如下： [c-sharp]view plaincopy 1.example 2.|——src 目录（存放源代码文件） 3. |——hello.c 4.|——lib 目录（存放用来生成库的文件） 5. |——test.c 用来生成静态库libhello.a 6.|——include 目录（存放程序中使用的头文件） 7. |——hello.h 2. 编写的各个目录下的源文件 [c-sharp]view plaincopy 1.hello.h 文件 2.extern void print(char *); 3.test.c 文件 4.#include
[c-sharp]view plaincopy 1.noinst_LIBRARIES=libhello.a 2.libhello_a_SOURCES=test.c 3.AUTOMAKE_OPTIONS=foreign 第一行noinst 表示生成的是静态库，不需要make install ，直接制定它的位置和名字就 可以使用。 第二行表示用来生成静态库的源文件。如果要把静态库生成到其他地方，可以在=后面 加上路径（建议用绝对路径，并将所要用到的静态库生成在同一个文件夹下，如lib）。 第三行AUTOMAKE_OPTIONS 是Automake 的选项。Automake 主要是帮助开发 GNU 软 件的人员来维护软件，所以在执行Automake 时，会检查目录下是否存在标准GNU 软件中 应具备的文件，例如 'NEWS'、'AUTHOR'、 'ChangeLog' 等文件。设置为foreign 时，Automake 会改用一般软件的标准来检查。如果不加这句的话，需要在autoconf之前，先执行touch NEWS README AUTHORS ChangeLog 来生成'NEWS'、'AUTHOR'、 'ChangeLog' 等文件4. 编写src/Makefile.am 文件 [c-sharp]view plaincopy 1.AUTOMAKE_OPTIONS=foreign 2.INCLUDES= -I../include 3.bin_PROGRAMS=hello 4.hello_SOURCES=hello.c 5.hello_LDADD=../lib/libhello.a 第二行指定头文件的位置，-I 是idirafter 的缩写。../include 指定头文件的位置，..是上 一级目录，也就是这里的example 目录。 第三行指定生成可执行文件名hello，在这里可执行文件生成在src 下，建议将可执行文 件生成到一个特定的文件夹下，让它和源代码分开，如/root/test 目录下。写法为： [c-sharp]view plaincopy 1.bin_PROGRAMS=/root/test/hello，后面的第四、五行也相对应地变为： 2._root_test_hello_SOURCES=hello.c 3._root_test_hello_LDADD=../lib/libhello.a
[Linux]链接,静态库和动态库
[Linux]链接，静态库和动态库 Filename：[Linux]链接，静态库和动态库 Version：V1.0 Date：12/01/2009 Author：S.C.Leon
1.4库文件是如何产生的在linux下 静态库的后缀是.a，它的产生分两步 Step 1.由源文件编译生成一堆.o，每个.o里都包含这个编译单元的符号表 Step 2.ar命令将很多.o转换成.a，成文静态库 动态库的后缀是.so，它由gcc加特定参数编译产生。 具体方法参见后文实例。 1.5库文件是如何命名的，有没有什么规范 在linux下，库文件一般放在/usr/lib和/lib下， 静态库的名字一般为libxxxx.a，其中xxxx是该lib的名称 动态库的名字一般为libxxxx.so.major.minor，xxxx是该lib的名称，major是主版本号，minor是副版本号 1.6如何知道一个可执行程序依赖哪些库 ldd命令可以查看一个可执行程序依赖的共享库， 例如# ldd /bin/lnlibc.so.6 => /lib/libc.so.6 (0×40021000)/lib/ld-linux.so.2 => /lib/ld- linux.so.2 (0×40000000) 可以看到ln命令依赖于libc库和ld-linux库 1.7可执行程序在执行的时候如何定位共享库文件 当系统加载可执行代码时候，能够知道其所依赖的库的名字，但是还需要知道绝对路径 此时就需要系统动态载入器(dynamic linker/loader) 对于elf格式的可执行程序，是由ld-linux.so*来完成的，它先后搜索elf文件的DT_RPATH段—环境变量LD_LIBRARY_PATH—/etc/ld.so.cache文件列表— /lib/,/usr/lib目录找到库文件后将其载入内存 如：export LD_LIBRARY_PATH=’pwd’ 将当前文件目录添加为共享目录 1.8在新安装一个库之后如何让系统能够找到他 如果安装在/lib或者/usr/lib下，那么ld默认能够找到，无需其他操作。
linux下静态库与动态库的区别
静态库与动态库 什么是库 库是写好的，现有的，成熟的，可以复用的代码。现实中每个程序都要依赖很多基础的底层库，不可能每个人的代码都从零开始，因此库的存在意义非同寻常。 本质上来说，库是一种可执行代码的二进制形式，可以被操作系统载入内存执行。库有两种：静态库（.a、.lib）和动态库（.so、.dll）。 所谓静态、动态是指链接。回顾一下，将一个程序编译成可执行程序的步骤： 静态库 之所以称为【静态库】，是因为在链接阶段，会将汇编生成的目标文件.o与引用到的库一起链接打包到可执行文件中。因此对应的链接方式称为静态链接。 试想一下，静态库与汇编生成的目标文件一起链接为可执行文件，那么静态库必定跟.o文件格式相似。其实一个静态库可以简单看成是一组目标文件（.o/.obj 文件）的集合，即很多目标文件经过压缩打包后形成的一个文件。静态库特点总结如下： ?静态库对函数库的链接是放在编译时期完成的。 ?程序在运行时与函数库再无瓜葛，移植方便。
?浪费空间和资源，因为所有相关的目标文件与牵涉到的函数库被链接合成一个可执行文件。 Linux下创建与使用静态库 Linux静态库命名规则 Linux静态库命名规范，必须是"lib[your_library_name].a"：lib为前缀，中间是静 态库名，扩展名为.a。 创建静态库（.a） 通过上面的流程可以知道，Linux创建静态库过程如下： ?首先，将代码文件编译成目标文件.o（StaticMath.o） g++ -c StaticMath.cpp 注意带参数-c，否则直接编译为可执行文件 ?然后，通过ar工具将目标文件打包成.a静态库文件 ar -crv libstaticmath.a StaticMath.o 生成静态库libstaticmath.a 图3.Linux下使用静态库 大一点的项目会编写makefile文件（CMake等等工程管理工具）来生成静态库，输入多个命令太麻烦了。 使用静态库 Linux下使用静态库，只需要在编译的时候，指定静态库的搜索路径（-L选 项）、指定静态库名（不需要lib前缀和.a后缀，-l选项）。 g++ TestStaticLibrary.cpp -L../StaticLibrary -lstaticmath
动态链接库及静态链接库(windows下的.dll.lib和linux下的.so.a)
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*/ #i nclude #i nclude int mai n() { Sayhello(); return 0; } 使用如下命令进行编译 $gcc -C testlib.c -o testlib.o 用如下命令连接： $gcc testlib.o -lhello -o testlib 在连接时要注意，假设libhello.o和libhello.a都在缺省的库搜索路径下/usr/lib下，如果在
3.动态库的路径问题 为了让执行程序顺利找到动态库，有三种方法：
Windows静态库和动态库演练
Windows的静态库和动态库： 演练：创建和使用静态库 在本演练中，您将创建一个静态库(LIB)，其中包含可供其他应用程序使用的有用例程。使用静态库是重用代码的一种绝佳方式。您不必在自己创建的每个程序中重新实现这些例程，而只需对这些例程编写一次，然后从需要该功能的应用程序引用它们即可。 本演练涵盖以下内容： 创建新的静态库项目 向静态库添加类 创建引用静态库的应用程序 在控制台应用程序中使用静态库的功能 运行应用程序 先决条件 本主题假定您具备C++语言的基础知识。 创建新的静态库项目 从“文件”菜单中，选择“新建”，然后选择“项目…”。 从“项目类型”窗格中，选择“Visual C++”下的“Win32”。 从“模板”窗格中，选择“Win32控制台应用程序”。 为项目选择一个名称，如“MathFuncsLib”，并将其输入“名称”字段。为解决方案选择一个名称，如“StaticLibrary”，并将其输入“解决方案名称”字段。 按“确定”启动Win32应用程序向导。在“Win32应用程序向导”对话框的“概述”页中，按“下一步”。
从“Win32应用程序向导”的“应用程序设置”页中，选择“应用程序类型”下的“静态库”。 从“Win32应用程序向导”的“应用程序设置”页中，取消选择“附加选项”下的“预编译头”。 按“完成”创建项目。 向静态库添加类 若要为新类创建头文件，请从“项目”菜单中选择“添加新项…”。将显示“添加新项”对话框。从“类别”窗格中，选择“Visual C++”下的“代码”。从“模板”窗格中选择“头文件(.h)”。为头文件选择一个名称，如“MathFuncsLib.h”，并按“添加”。将显示一个空白文件。 添加一个名为“MyMathFuncs”的简单类，以执行常见的算术运算，如加、减、乘和除。代码应与以下内容类似： //MathFuncsLib.hnamespace MathFuncs{class MyMathFuncs{public: //Returns a+b static double Add(double a,double b);//Returns a-b static double Subtract(double a,double b);//Returns a*b static double Multiply(double a,double b);//Returns a/b//Throws DivideByZeroException if b is0static double Divide(double a,double b);};} 若要为新类创建源文件，请从“项目”菜单中选择“添加新项…”。将显示“添加新项”对话框。从“类别”窗格中，选择“Visual C++”下的“代码”。从“模板”窗格中，选择“C++文件(.cpp)”。为源文件选择一个名称，如“MathFuncsLib.cpp”，并按“添加”。将显示一个空白文件。 在源文件中实现“MyMathFuncs”的功能。代码应与以下内容类似： //MathFuncsLib.cpp//compile with:/c/EHsc#include"MathFuncsLib.h"#include
MinGW_Eclipse开发静态库和动态库
MinGW_EclipseCDT开发C++动态库、静态库本文主要介绍C++使用MinGW进行跨平台开发时如何创建与使用静态库、动态库。 文章分为以下几个部分： 第一部分介绍了Linux和MinGW使用Gcc编译器创建和使用静态库与动态库的基本方法。 第二部分介绍了MinGW与MSVC库间的转换及其调用。
第一部分GCC系列编译器下的静态库与动态库 一什么是库 所谓库就是已经写好的，成熟的，可以复用的代码—这些代码往往不开源，但在实践中非常有用。现实中每个程序都要依赖很多基础的底层库，不可能每个人的代码都从零开始，C语言中有stdio和stdlib等；C++中有STL和Boost都是程序员不可缺少的库。 本质上来说库是一种可执行代码的二进制形式，可以被操作系统载入内存执行。 库有两种：静态库（文件后缀分别为.a、.lib）和动态库（文件后缀分别为.so、.dll）。 所谓静态、动态是指链接。回顾一下，将一个程序编译成可执行程序的步骤： 图：编译过程 二静态库 之所以称之为静态库，因为编译器在链接阶段，会将汇编生成的目标文件.o与引用到的库一起链接打包到可执行文件中。因此对应的链接方式称为静态链接。 试想一下，静态库与汇编生成的目标文件一起链接为可执行文件，那么静态库必定跟.o文件格式相似。其实一个静态库可以简单看成是一组目标文件（.o/.obj文件）的集合，即很多目标文件经过压缩打包后形成的一个文件。静态库特点总结： ●静态库对函数库的链接是放在编译时期完成的。 ●程序在运行时与函数库再无瓜葛，移植方便。 ●浪费空间和资源，因为所有相关的目标文件与牵涉到的函数库被链接合成一个可执行文件。 编译器在编译时将目标文件压缩到一起，并且对其进行编号和索引，以便于查找和检索。一般创建静态库的步骤如图所示：
linux下静态链接库和动态链接库编译和使用[1]
Linux 下编译链接动静态库 2010年03月29日星期一 17:11 Linux 版本是 Red Hat 9 ,内核版本是 2.4.18 输入 which gcc 查看 gcc 的位置在 /usr/bin/gcc gcc -v 查看 gcc 编译前的配置信息 --prefix=/usr 说明了安装目录 没有 --with-headers 说明默认的 include 就在安装目录下 所以 gcc 默认的 include 目录是 /usr/include ,要包含另一个目录, 可以用 -I dir 选项包含该目录,想要更方便的可以 在 /etc/profile 中添加一个环境变量 C_INCLUDE_PATH C_INCLUDE_PATH="your include path" export C_INCLUDE_PATH gcc 默认的 lib 目录很多,一般是 /lib 和 /usr/lib 可以输入 gcc -print-search-dirs 查看 同样可以在编译时通过 -L dir 来添加,也可以在 /etc/profile 中添加 LD_LIBRARY_PATH="your ldlib path" export LD_LIBRARY_PATH 还有就是可以/etc/ld.so.conf中添加目录,这对于安装别的库很方便 当然修改了库文件后需要运行一下ldconfig 自己制作交叉编译工具太复杂了,直接下一个arm-linux-gcc-3.4.1.tar.bz2 tar jxvf arm-linux-gcc-3.4.1.tar.bz2 -C / 解压缩到根目录下 其实由于压缩包带的目录是 usr/local/arm/3.4.1 所以实际还是在 /usr/local/arm/3.4.1 目录下 在bin中可以看到各个工具 arm-linux-gcc ... 输入 ./arm-linux-gcc -v 可以看到配置信息 有 --with-headers=/usr/local/arm/3.4.1/arm-linux/include 说明了默认的include目录 输入 ./arm-linux-gcc -print-search-dirs 查看搜索的 lib 目录,主要的库文件还是在 /usr/local/arm/3.4.1/arm-linux/lib目录下. arm-linux-gcc 3.4.1 可以用来编译2.6的内核 而编译bootloader还是用原来的2.95.2版的 arm-linux-gcc 程序的预处理、编译、链接都可以由gcc完成，gcc会自动调用cpp来做预处理，ld来进行链接。其中对库的链接是很重要的一部分，有静态库和动态库两种，静态库以 .a 为后缀，ld会把静态库中的代码拷到待链接的程序中，形成完整的可执行的程序。而链接动态库生成可执行程序又分为静态调用和动态调用，静态调用是在程序中包含头文件直接调用库函数，也叫显式调用，程序被加载的同时也加载了库，在加载时完成真正的地址链接。而动态调用则不需要包含头文件，在程序中使用库加载函数dlopen来加载库，使用dlsym来获取所需函数的地址，所以是在需要时才加载动态库，也是隐式调用。这样编译时和库就没有关系，不需要链接了。
动态库与静态库优缺点比较
动态库与静态库优缺点比较 我们在编写一个C语言程序的时候，经常会遇到好多重复或常用的部分，如果每次都重新编写固然是可以的，不过那样会大大降低工作效率，并且影响代码的可读性，更不利于后期的代码维护。我们可以把他们制作成相应的功能函数，使用时直接调用就会很方便，还可以进行后期的功能升级。例如我要在一段代码中多次交换两个变量的值，我可以在代码中多次写入i=x; x=y; y=i; 不过这样未免有点麻烦我们可以编写一个change_two_int()函数进行简化。 定义如下函数： void change_two_int(int *a，int *b) { int c; c=*a; *a=*b; *b=c; } 这样每次要进行交换时只需调用change_two_int(&x , &y);即可，是否方便了许多？那么我们要讨论的和这
些有什么关系呢？库通俗的说就是把这些常用函数的目标 文件打包在一起，提供相应函数的接口，便于程序员使用。库是别人写好的现有的，成熟的，可以复用的代码，我们只需要知道其接口如何定义，便可以自如使用。现实中每个程序都要依赖很多基础的底层库，不可能每个人的代码都从零开始，因此库的存在意义非同寻常。比如我们常使用的printf函数，就是c标准库提供的函数。我们在使用时只需要包含相应的头文件就可以使用（非静态编译还要有相应的库文件）。而不用关心printf函数具体是如何实现的，这样就大大提高了程序员编写代码的效率。从使用方法上分库大体上可以分为两类：静态库和共享库。在windows中静态库是以.lib 为后缀的文件，共享库是以.dll 为后缀的文件。在linux中静态库是以.a 为后缀的文件，共享库是以.so为后缀的文件。 以linux下的静态库和动态库为例我们研究一下，首先我们看一下他们的生成方式静态库： 首先将源文件编译成目标文件：gcc –c a.c b.c 生成静态库：ar –rc libstatic.a a.o b.o共享库： 同静态库一样编译成目标文件：gcc –c a.c b.c 生成共享库：gcc –fPIC –shared –o libshared.so a.o b.o 由此可见静态库和动态库都是对目标文件的处理，也可以说库文件已经是机器码文件了，静态库和共享库的加载过程有
静态库和动态库 共享库
静态库与动态库的区别 lib和dll文件的区别和联系 .dll是在你的程序运行的时候才连接的文件，因此它是一种比较小的可执行文件格式，.dll还有其他的文件格式如.ocx等，所有的.dll文件都是可执行。 .lib是在你的程序编译连接的时候就连接的文件，因此你必须告知编译器连接的lib文件在那里。一般来说，与动态连接文件相对比，lib文件也被称为是静态连接库。当你把代码编译成这几种格式的文件时，在以后他们就不可能再被更改。如果你想使用lib文件，就必须： 1。包含一个对应的头文件告知编译器lib文件里面的具体内容 2。设置lib文件允许编译器去查找已经编译好的二进制代码 如果你想从你的代码分离一个dll文件出来代替静态连接库，仍然需要一个lib文件。这个lib文件将被连接到程序告诉操作系统在运行的时候你想用到什么dll文件，一般情况下，lib文件里有相应的dll文件的名字和一个指明dll输出函数入口的顺序表。如果不想用lib文件或者是没有lib文件，可以用WIN32 API 函数LoadLibrary、GetProcAddress。事实上，我们可以在Visual C++ IDE中以二进制形式打开lib文件，大多情况下会看到ASCII码格式的C++函数或一些重载操作的函数名字。 一般我们最主要的关于lib文件的麻烦就是出现unresolved symble 这类错误，这就是lib文件连接错误或者没有包含.c、.cpp文件到工程里，关键是如果在C++工程里用了C语言写的lib文件，就必需要这样包含： extern "C" { #include "myheader.h" } 这是因为C语言写的lib文件没有C++所必须的名字破坏，C函数不能被重载，因此连接器会出错 C语言中有一些函数不需要进行编译，有一些函数也可以在多个文件中使用。一般来说，这些函数都会执行一些标准任务，如数据库输入/输出操作或屏幕控制等。可以事先对这些函数进行编译，然后将它们放置在一些特殊的目标代码文件中，这些目标代码文件就称为库。库文件中的函数可以通过连接程序与应用程序进行连接。这样就不必在每次开发程序时都对这些通用的函数进行编译了。 不同类型的应用程序将会使用不同的函数库。例如：libdbm库中组包含了对数据库文件进行访问的dbm函数，需要对数据库进行操作的程序就会与该库进行连接。数学应用程序将使用数学库libm， X-Windows应用程序将使用Xlib库，libX11。另外，所有的程序都将使用标准的C函数库。libc，该库中包含了诸好内存管理或输入输出操作的基本函数，这些库都存放在/usr/lib这些系统公用的目录中，系统中的任何用户都可以利用这些库。当然用户也可以建立自己专用的库函数，供自己或其它指定的人员使用。 库可以有三种使用的形式：静态、共享和动态。静态库的代码在编译时就已连接到开发人员开发的应用程序中，而共享库只是在程序开始运行时才载入，在编译时，只是简单地指定需要使用的库函数。动态库则是共享库的另一种变化形式。动态库也是在程序运行时载入，但与共享库不同的是，使用的库函数不是在程序运行开始，而是在程序中的语句需要使用该函数时才载入。动态库可以在程序运行期间释放动
静态链接库与动态链接库的异同点
先来阐述一下DLL（Dynamic Linkable Library）的概念，你可以简单的把DLL看成一种仓库，它提供给你一些可以直接拿来用的变量、函数或类。在仓库的发展史上经历了“无库－静态链接库－动态链接库”的时代。静态链接库与动态链接库都是共享代码的方式，如果采用静态链接库，则无论你愿不愿意，lib 中的指令都被直接包含在最终生成的EXE文件中了。但是若使用DLL，该DLL不必被包含在最终EXE文件中，EXE文件执行时可以“动态”地引用和卸载这个与EXE独立的DLL文件。静态链接库和动态链接库的另外一个区别在于静态链接库中不能再包含其他的动态链接库或者静态库，而在动态链接库中还可以再包含其他的动态或静态链接库。 目标库（Object Libraries） 目标库又叫静态链接库，是扩展名为.LIB的文件，包括了用户程序要用到的各种函数。它在用户程序进行链接时，“静态链接”到可执行程序文件当中。例如，在VC++中最常使用到的C运行时目标库文件就是LIBC.LIB。在链接应用程序时常使用所谓“静态链接”的方法，即将各个目标文件(.obj)、运行时函数库(.lib)以及已编译的资源文件(.res)链接到一起，形成一个可执行文件 (.exe)。使用静态链接时，可执行文件需要使用的各种函数和资源都已包含到文件中。这样做的缺点是对于多个程序都使用的相同函数和资源要重复链接到exe 文件中，使程序变大、占用内存增加。 动态链接库（Dynamic-Link Libraries） “动态链接”是将一些公用的函数或资源组织成动态链接库文件(.dll)，当某个需要使用dll中的函数或资源的程序启动时(准确的说是初始化时)，系统将该dll映射到调用进程的虚拟地址空间、增加该dll的引用计数值，然后当实际使用到该dll时操作系统就将该dll载入内存；如果使用该dll的所有程序都已结束，则系统将该库从内存中移除。使用同一dll的各个进程在运行时共享dll 的代码，但是对于dll中的数据则各有一份拷贝(当然也有在dll中共享数据的方法)。动态链接库中可以定义两种函数：输出函数和内部函数。输出函数可以被其他模块调用，内部函数只能被动态链接库本身调用。动态链接库也可以输出数据，但这些数据通常只被它自己的函数所使用。 静态链接库与动态链接库的相同点：
h头文件 .lib库文件 .dll动态链接库文件关系
h头文件 .lib库文件 .dll动态链接库文件关系 .h头文件是编译时必须的，lib是链接时需要的，dll是运行时需要的。 附加依赖项的是.lib不是.dll，若生成了DLL,则肯定也生成LIB文件。如果要完成源代码的编译和链接，有头文件和lib就够了。如果也使动态连接的程序运行起来，有dll就够了。在开发和调试阶段，当然最好都有。 .h .lib .dll三者的关系是： H文件作用是:声明函数接口 DLL文件作用是: 函数可执行代码 当我们在自己的程序中引用了一个H文件里的函数,编链器怎么知道该调用哪个DLL文件呢?这就是LIB文件的作用: 告诉链接器调用的函数在哪个DLL中，函数执行代码在DLL中的什么位置，这也就是为什么 需要附加依赖项 .LIB文件，它起到桥梁的作用。如果生成静态库文件，则没有DLL ，只有lib，这时函数可执行代码部分也在lib文件中 目前以lib后缀的库有两种，一种为静态链接库(Static Libary，以下简称“静态库”)，另一种为动态连接库(DLL，以下简称“动态库”)的导入库(Import Libary，以下简称“导入库”）。静态库是一个或者多个obj文件的打包，所以有人干脆把从obj文件生成lib的过程称为Archive，即合并到一起。比如你链接一个静态库，如果其 中有错，它会准确的找到是哪个obj有错，即静态lib只是壳子。动态库一般会有对应的导入库，方便程序静态载入动态链接库，否则你可能就需要自己LoadLibary调入DLL文件，然后再手工GetProcAddress 获得对应函数了。有了导入库，你只需要链接导入库后按照头文件函数接口的声明调用函数就可以了。导 入库和静态库的区别很大，他们实质是不一样的东西。静态库本身就包含了实际执行代码、符号表等等， 而对于导入库而言，其实际的执行代码位于动态库中，导入库只包含了地址符号表等，确保程序找到对应 函数的一些基本地址信息。 一般的动态库程序有lib文件和dll文件。lib文件是必须在编译期就连接到应用程序中的，而dll文件是运 行期才会被调用的。如果有dll文件，那么对应的lib文件一般是一些索引信息，具体的实现在dll文件中。如果只有lib文件，那么这个lib文件是静态编译出来的，索引和实现都在其中。静态编译的lib文件有好处：给用户安装时就不需要再挂动态库了。但也有缺点，就是导致应用程序比较大，而且失去了动态库的灵活性，在版本升级时，同时要发布新的应用程序才行。在动态库的情况下，有两个文件，而一个是引入库（.LIB）文件，一个是DLL文件，引入库文件包含被DLL导出的函数的名称和位置，DLL包含实际的函数和数据，应用程序使用LIB文件链接到所需要使用的DLL文件，库中的函数和数据并不复制到可执行文件中，因此在应用程序的可执行文件中，存放的不是被调用的函数代码，而是DLL中所要调用的函数的内存地址，这样当一个或多个应用程序运行是再把程序代码和被调用的函数代码链接起来，从而节省了内存资源。从上 面的说明可以看出，DLL和.LIB文件必须随应用程序一起发行，否则应用程序将会产生错误。
- 第三阶段学习总结,静态库和动态库的创建和使用C 篇
- h头文件 .lib库文件 .dll动态链接库文件关系
- 静态链接库LIB和动态链接库DLL的区别
- linux中编译静态库(.a)和动态库(.so)的基本方法_onlyyou
- GCC编译动态和静态链接库
- [Linux]链接,静态库和动态库
- 动态库与静态库优缺点比较
- linux下用gcc生成静态库和动态库
- 动态链接库及静态链接库(windows下的.dll .lib和linux下的.so .a)
- linux下的静态库与动态库的区别和使用
- C语言程序静态库和动态库的创建及其应用
- Windows静态库和动态库演练
- gcc生成.a静态库和.so动态库
- gcc生成静态库和动态库
- linux 下查看动态库和静态库的方法
- VS2008静态库和动态库的创建和调用
- 实验3：动态库和静态库的制作和使用
- linux下静态链接库和动态链接库编译和使用[1]
- Linux静态链接库动态链接库的创建和使用及区别
- 动态库与静态库的原理介绍