Windows静态库和动态库的创建和使用 (lib vs dll)

偶们在实际的编程开发中，经常会遇到运行时无法找到某个DLL文件或者链接时无法找到某个LIB文件。然后，我们就开始乱GOOGLE一下，然后将VS2005的设置改变一下，或许就Ok了，我们将别人开发的DLL或者LIB导入到我们的编程中，那么这些lib，DLL到底是什么呢？下面，偶就细细道来。

 

首先，偶们说第一个：静态链接库（Static Libary）

偶们用VS2005做一个静态链接库先

打开VS2005，新建à项目（staticCai）àWin32控制台应用程序

 

新建static_lib.h 和static_lib.cpp 两个文件，这两个文件的内容如下

：

 

 

 

static_lib.h：

 

int add(int x,int y);

int substract(int x , int y);

 

static_lib.cpp：

 

#include "static_lib.h"

 

int add(int x,int y)

{

       return x + y;

}

 

int substract(int x,int y)

{

       return x - y;

}

 

然后编译，生成解决方案，好，这样不出意外会在debug文件夹（与staticCai并列）下生成一个staticCai.lib文件，好了，这个就是我们做好的静态链接库。下面，我们看看怎么用这个静态链接库。我们再新建一个win32控制台程序，新建main.cpp内容如下：

#include <iostream>

#include "static_lib.h"

#pragma comment(lib, "static.lib")

using namespace std ;

 

int main()

{

       cout << add(3 ,4) << endl ;

       cout << substract(5 , 3) << endl ;

       return 0 ;

}

 

并且将staticCai.lib和static_lib.h这两个文件拷贝到与main.cpp并列的文件夹下。然后，我们编译，链接，执行程序，就会出结果了

#pragma comment(lib, "static.lib")这句和我们在 项目à属性à连接器à添加依赖项 的效果是一样的。至此，怎么做静态链接库以及怎么用静态链接库就搞定了。现在，我们把刚刚拷贝过来的staticCai.lib给删了，我们发现，程序照样执行，但是不能再链接了。所以，我们得出这样的结论：我们再链接的时候需要静态链接库，一旦链接成功，生成了可执行文件，那么，静态链接库就不再需要了。

其次，偶们说第二个：动态链接库（dynamic link Libary）

同样，我们来做一个动态链接库，和上面的步骤一样，先建工程，只有最后一步稍有不同

 

然后，新建Dll.cpp文件（这里我们就不做.h文件了），敲入一下内容：

#define  DLL_API _declspec(dllexport)

#include <iostream>

using namespace std;

DLL_API int add(int a,int b)   //实现两个整数相加

{

       return a+b;

}

DLL_API int subtract(int a,int b)   //实现两个整数相减

{

       return a-b;

}

 

然后，我们编译，生成解决方案，就会在debug文件夹下生成dllCai.dll和dllCai.lib。好，至此，动态链接库就做好了，下面我们来看怎么用，新建一个win32控制台程序，新建main.cpp内容如下：

#include <iostream>

using namespace std ;

#pragma comment(lib, "DLL.lib")

extern int add(int a,int b);

extern int subtract(int a,int b);

int main()

{

       cout << add(3 ,4) << endl ;

       cout << subtract(5 , 3) << endl ;

       return 0 ;

}

 

然后把dllCai.dll和dllCai.lib拷贝到与main.cpp并列的目录下。接着，编译，链接，执行，就会看到和上一次一样的结果了。然后，我们把dllCai.lib给删了，程序照样执行，但是不能再链接了，接着，我们把dllCai.dll给删了，程序可以再编译，链接，但是执行的时候就黄了

 

 

所以，我们说：对于动态链接库，链接的时候需要.lib文件，运行的时候需要.dll文件。

 

至此，静态链接库和动态链接库我们就说完了，我们做一下对比和补充：

1 、 两个lib文件

我们发现，无论是静态链接库还是动态链接库，最后都有lib文件，那么两者区别是什么呢？其实，两个是完全不一样的东西。staticCai.lib的大小为4KB，dllCai.lib的大小为2KB，静态库对应的lib文件叫静态库，动态库对应的lib文件叫导入库。实际上静态库本身就包含了实际执行代码、符号表等等，而对于导入库而言，其实际的执行代码位于动态库中，导入库只包含了地址符号表等，确保程序找到对应函数的一些基本地址信息。

2 、 对于静态链接库，我们在编译和链接的时候已经将所有的代码都导入进来，因此，当生成可执行文件以后，可执行文件包含所有的代码。因此，在可执行文件运行时就不再需要静态库了，这也是为什么我们删掉staticCai.lib程序照样执行；而对于动态链接库，实际上，可执行文件不包含DLL中的内容，只是通过导入库（.lib）知道了相应的地址信息，因此，可执行文件在运行时动态得去加载DLL，这也是为什么我们删掉dllCai.dll后程序就不能执行了。

3 、 对于DLL，我们是可以不要lib文件的。

如果不要lib文件，我们可以通过函数指针的使用达到我们的目的：

#define  DLL_API _declspec(dllexport)

#include <iostream>

using namespace std;   //注意这里的extern "C" ， 这里必须加

extern "C" DLL_API int add(int a,int b)   //实现两个整数相加

{

       return a+b;

}

extern "C" DLL_API int subtract(int a,int b)   //实现两个整数相减

{

       return a-b;

}

#include <iostream>

#include <Windows.h>

using namespace std ;

 

typedef int (*func)(int x , int y);  //函数指针

int main()

{

       HINSTANCE hInstance = LoadLibrary("DLL.dll");

       if(hInstance == NULL)

       {

              cout << "SB" << endl ;

              return 0;

       }

       func add = (func)GetProcAddress(hInstance, "add");

       func sub = (func)GetProcAddress(hInstance, "subtract");

       cout << (*add)(3,4) << endl ;

       cout << (*sub)(5,3) << endl ;

}

 

显然，这种方法没有用lib文件方便，如果为了每次调用一个函数还要自己再弄一个函数指针，多麻烦啊，所以，我们在实际开发中，用的众多的第三方扩展库，别人都是提供的：

.h  文件（类，函数的声明）

.dll 文件（类或函数的实现）

.lib 文件（导入库）

小结：

一、静态库

* 静态库是把程序运行时需要使用的函数编译在一个二进制文件中，扩展名为.lib。当程序link时把静态库中的二进制数据和程序其它数据放到一起。程序运行时不在需要lib和dll文件的支持。这样做的坏处是开发出来的程序占用磁盘空间较大。特别是windows系统中本来就有或很多程序运行都需要的函数完全没有必要每次开发程序时都要使用各自的静态库。

* 静态库为.lib文件形式存在

* 链接后产生的可执行文件包含了所有需要调用的函数的代码，因此占用磁盘空间较大

* 如果有多个(调用相同库函数的)进程在内存中间时运行，内存中就存有多份相同的库函数代码，因此占用内存空间较多。

二、动态库

* 动态库在开发时仅是把dll中的函数名和参数放到应用程序中，应用程序运行时根据函数名和参数调用dll中的函数来运行，这样操作系统中的应用程序可以同时使用同一个dll。可以有效地节省硬盘空间，当然这样做使得程序设计更有层次。也有利于软件工程师的分工和信息安全

* 动态库以.dl文件形式存在，且一般都有一个对应的引入库以.lib文件形式存在。纯资源dll不生成.lib引入库。

   >引入库和静态库的扩展名均为*.lib，但是引入库仅包含一些函数名和参数信息，没有函数体，是为调用动态库服务的，它和动态库的关系相当于.h文件和.cpp文件之间的关系；

* 动态库两种绑定方式

   >静态绑定(static blnding) 使用静态绑定的程序在一开始载入内存的时候，载入程序就会把程序所有调用到的动态代码的地址算出、确定下来。这种方式使程序刚运行时的初始化时间较长，不过一但完成动态装载，程序的运行速度就很快。

    2动态绑定(dynamic binding)   使用这种方式的程序并不在一开始就完成动态链接，而是直到真正调用动态库代码时，载入程序才计算(被调用的那部分)动态代码的逻辑地址，然后等到某个时候，程序又需要调用另外某块动态代码时，载入程序才又去计算这部分代码的逻辑地址。所以，这种方式侄程序初始化时间较短，但运行期间的性能比不上静态绑定的程序。

* 使用动态库的两种方法（windows）

  >方法一： load-time dynamic linking 
在要调用dll的应用程序链接时，将dll的输入库文件(import library，.lib文件)包含进去。具体的做 法是在源文件开头加一句#include ，然后就可以在源文件中调用dlldemo.dll中的输出文件了。

  >方法二： run-time dynamic linking 
不必在链接时包含输入库文件，而是在源程序中使用LoadLibrary或LoadLibraryEx动态的载入dll。

 

=============================================

静态库和动态库的区别

1. 静态函数库

    这类库的名字一般是libxxx.a；利用静态函数库编译成的文件比较大，因为整个 函数库的所有数据都会被整合进目标代码中，他的优点就显而易见了，即编译后的执行程序不需要外部的函数库支持，因为所有使用的函数都已经被编译进去了。当然这也会成为他的缺点，因为如果静态函数库改变了，那么你的程序必须重新编译。

2. 动态函数库

    这类库的名字一般是libxxx.so;相对于静态函数库，动态函数库在编译的时候 并没有被编译进目标代码中，你的程序执行到相关函数时才调用该函数库里的相应函数，因此动态函数库所产生的可执行文件比较小。由于函数库没有被整合进你的程序，而是程序运行时动态的申请并调用，所以程序的运行环境中必须提供相应的库。动态函数库的改变并不影响你的程序，所以动态函数库的升级比较方便。
linux系统有几个重要的目录存放相应的函数库，如/lib /usr/lib。

静态库的使用

静态库的操作工具：gcc和ar 命令。 

编写及使用静态库 

(1)设计库源码 pr1.c 和 pr2.c 

[root@billstone make_lib]# cat pr1.c 

void print1() 

{ 

                printf("This is the first lib src!\n"); 

} 

[root@billstone make_lib]# cat pr2.c 

void print2() 

{ 

                printf("This is the second src lib!\n"); 

} 

       (2)  编译.c 文件 

[bill@billstone make_lib]$ cc -O -c pr1.c pr2.c 

[bill@billstone make_lib]$ ls -l pr*.o 

-rw-rw-r--        1 bill          bill                    804    4 月  15 11:11 pr1.o 

-rw-rw-r--        1 bill          bill                    804    4 月  15 11:11 pr2.o 

(3)  链接静态库 

    为了在编译程序中正确找到库文件,静态库必须按照 lib[name].a 的规则命名,如下例中[name]=pr. 

[bill@billstone make_lib]$ ar -rsv libpr.a pr1.o pr2.o 

a - pr1.o 

a - pr2.o 

[bill@billstone make_lib]$ ls -l *.a 

-rw-rw-r--        1 bill          bill                  1822    4 月  15 11:12 libpr.a 

[bill@billstone make_lib]$ ar -t libpr.a 

pr1.o 

pr2.o 

(4)  调用库函数代码 main.c 

[bill@billstone make_lib]$ cat main.c 

int main() 

{ 

                print1(); 

                print2(); 

                return 0; 

} 

(5)  编译链接选项 

    -L 及-l 参数放在后面.其中,-L 加载库文件路径,-l 指明库文件名字. 

[bill@billstone make_lib]$ gcc -o main main.c -L./ -lpr 

[bill@billstone make_lib]$ ls -l main* 

-rwxrwxr-x        1 bill          bill                11805    4 月  15 11:17 main 

-rw-rw-r--        1 bill          bill                      50    4 月  15 11:15 main.c 

(6)执行目标程序 

[bill@billstone make_lib]$ ./main 

This is the first lib src! 

This is the second src lib! 

[bill@billstone make_lib]$ 

动态库的使用

编写动态库 

(1)设计库代码 

[bill@billstone make_lib]$ cat pr1.c 

int p = 2; 

void print(){ 

                printf("This is the first dll src!\n"); 

} 

[bill@billstone make_lib]$   

(2)生成动态库 

[bill@billstone make_lib]$ gcc -O -fpic -shared -o dl.so pr1.c 

[bill@billstone make_lib]$ ls -l *.so 

-rwxrwxr-x        1 bill          bill                  6592    4 月  15 15:19 dl.so 

[bill@billstone make_lib]$ 

动态库的隐式调用 

  在编译调用库函数代码时指明动态库的位置及名字,  看下面实例 

[bill@billstone make_lib]$ cat main.c 

int main() 

{ 

                print(); 

                return 0; 

} 

[bill@billstone make_lib]$ gcc -o tdl main.c ./dl.so 

[bill@billstone make_lib]$ ./tdl 

This is the first dll src! 

[bill@billstone make_lib]$ 

当动态库的位置活名字发生改变时,  程序将无法正常运行;  而动态库取代静态库的好处之一则是通过更新动态库而随时升级库的内容. 

动态库的显式调用 

  显式调用动态库需要四个函数的支持,  函数 dlopen 打开动态库,  函数 dlsym 获取动态库中对象基址,  函数 dlerror 获取显式动态库操作中的错误信息,  函数 doclose 关闭动态库.

[bill@billstone make_lib]$ cat main.c 

#include <dlfcn.h>  

int main()  

{  

                void *pHandle;  

                void (*pFunc)();                                                    //  指向函数的指针 

                int *p;  

                pHandle = dlopen("./d1.so", RTLD_NOW);                  //  打开动态库 

                if(!pHandle){  

                                printf("Can't find d1.so \n"); 

                                exit(1);  

                }  

                pFunc = (void (*)())dlsym(pHandle, "print");                //  获取库函数 print 的地址 

                if(pFunc)  

                                pFunc();  

                else  

                                printf("Can't find function print\n"); 

                p = (int *)dlsym(pHandle, "p");                                      //  获取库变量 p 的地址 

                if(p)  

                                printf("p = %d\n", *p); 

                else  

                                printf("Can't find int p\n"); 

                dlclose(pHandle);                                                                //  关闭动态库 

                return 0;  

}  

 

[bill@billstone make_lib]$ gcc -o tds main.c –ld1 –L.

此时还不能立即./tds，因为在动态函数库使用时，会查找/usr/lib、/lib目录下的动态函数库，而此时我们生成的库不在里边。 这个时候有好几种方法可以让他成功运行： 最直接最简单的方法就是把libstr_out.so拉到/usr/lib或/lib中去。 还有一种方法 export LD_LIBRARY_PATH=$(pwd) 另外还可以在/etc/ld.so.conf文件里加入我们生成的库的目录，然后/sbin/ldconfig。 /etc/ld.so.conf是非常重要的一个目录，里面存放的是链接器和加载器搜索共享库时要检查的目录，默认是从/usr/lib /lib中读取的，所以想要顺利运行，我们也可以把我们库的目录加入到这个文件中并执行/sbin/ldconfig 。另外还有个文件需要了解/etc/ld.so.cache,里面保存了常用的动态函数库，且会先把他们加载到内存中，因为内存的访问速度远远大于硬盘的访问速度，这样可以提高软件加载动态函数库的速度了。

库依赖的查看

使用ldd命令来查看执行文件依赖于哪些库。

该命令用于判断某个可执行的 binary 档案含有什么动态函式库。
[root@test root]# ldd [-vdr] [filename]
参数说明：
--version　　打印ldd的版本号
-v --verbose　　打印所有信息，例如包括符号的版本信息
-d --data-relocs　　执行符号重部署，并报告缺少的目标对象（只对ELF格式适用）
-r --function-relocs　　对目标对象和函数执行重新部署，并报告缺少的目标对象和函数（只对ELF格式适用）
--help 用法信息。

如果命令行中给定的库名字包含'/'，这个程序的libc5版本将使用它作为库名字；否则它将在标准位置搜索库。运行一个当前目录下的共享库，加前缀"./"。