静态库和动态库详解

静态库和动态库详解

静态库和动态库的一些道道还是需要仔细的了解，否则从事linux和windows开发，总会出问题，例如用Visual Studio 2015企业版安装插件（VC_Linux即Visual C++ for Linux Development）可以连接linux，进行编写linux下的程序，若是不懂静态库和动态库的制作，就编译不通过，自然会抱怨网络教程怎么会如此惨淡。

1． 基本概念：

a) 库的概念

库是一种可执行代码的二进制形式，可以被操作系统（win,unix）载入内存执行。

库是写好的，可以复用的，每个程序都要依赖很多基础的底层库，库封装了太多的接口，不可能每一个人的代码都是从零开始的，因此库的存在意义非同寻常，常用静态库和动态库，就会多了解到c语言的接口封装的。

win和unix两个大型平台，存在着大量的库，二者的二进制编码是不兼容的。win下的和linux不同，本文重在linux下，不要被误解。win下就是lib和dll，linux下就是.a，.so，你通常能在windows下的程序中（QQ,360安全卫士）看见dll，但是很难见到lib。

b) linux下的标准库三种链接方式：

l 全静态：-static –pthread –lrt –ldl

n 优点:不会发生linux不同版本不兼容的情况

n 缺点:生成的文件较大

l 全动态库： -pthread –lrt –ldl

n 优点：生成的可执行程序最小

n 缺点：容易发生不兼容问题

l 半静态：-static –libgcc –L –pthread –lrt –ldl

n 优点：灵活，结合了全静态和全动态两种优点

n 缺点：比较难识别的哪些库容易发生不兼容问题，目前，只能依靠经验积累。

c) 库的种类

linux下库有2种：静态库（.a，.lib）和动态库（共享库.so，.dll）

所谓的静态和动态是指链接，一个程序在运行时，调用到别的库文件的函数，就是链接。

下图将一个程序编译成可执行程序的一般步骤：

图1.1 编译过程

静态库和动态库的区别来自于链接阶段，如何处理库，链接成可执行程序，分别称为静态链接方式、动态链接方式。

由于二者代码被载入时刻不同，那么有什么分别呢？

静态库的代码在编译过程中已经被 完整的拷贝 载入到可执行程序，体积较大，被使用多次，就会有N份冗余拷贝。一旦这个使用静态库的程序，就会连接到程序所需的函数，然后将它们拷贝到执行文件，一旦连接成功，这个静态库就不再需要了。也就说：静态库的静态链接表示静态性，在编译连接之后，lib，.a库中的所需要的函数都已经在执行程序中了，也就是一直存在，也就是再调用这个库中的函数，不再需要加载了，没有依赖性了。换言之：生成执行程序之后，lib库就没有作用了。如果静态里面的函数发生了变化，整个应用程序也要发生重新编译。

共享库的代码是在可执行程序时才会载入到内存中，在编译过程之中仅仅做简单的引用，代码体积较小，链接时不复制，程序运行时由操作系统动态加载到内存之中，供程序调用，系统只会加载一次，多个程序可以共用，节省了内存。程序对动态库具有依赖性，需要手动加入动态库。如果函数发生了变化，只需要重新编译动态库即可，不会影响到你的程序，所以动态库的升级和更新比较方便

换言之：程序运行时，程序必须加入动态库才可以运行。需要一个动态库就加载一个，需要几个就加载几个，没有找到就不能运行程序。而静态库就是把这些库放在可执行文件中，造成体积较大。而不另外加载其余的文件，所拥有的静态库也都可以删除了。

为什么静态库体积较大，就是把静态库放入到了可执行文件中了。

那有人会问，为什么不加载源文件，放什么静态库和动态库呢?.c.cpp，这些不直接编译就可以了吗？

答案就是：别人不想让你看到源码，就给你个接口，供你使用。而你要使用，就要么让可执行文件大点，要么就是加载很多.dll和.so动态库文件了。

共同点：为了不暴露源代码，程序员们想出了封装库这种方法。静态库和动态库都是闭源库，只能拿来满足某个功能的使用，不会暴露出内部的具体代码信息。开源库，就是你可以看见里面具体是如何实现的，github里面有大量的第三方库，可以学习学习。

区别：静态库就是直接将需要的代码放进可执行程序中，而动态库就是在需要调用其中的某个函数时，根据函数的映射表（调用函数先后次序），找到该函数，就调到堆或者栈去处理了。

做成静态库可执行文件较大，但不必附带库，做成动态库可执行文件本身比较小，但是需要依赖库

在网络上，流行的只有两个操作系统平台unix和windows，别管linux，那是属于unix的一种，暂且论为一种好吧。

unix下使用ar工具、windows下，vs使用lib.exe，将目标文件压缩在一起，并且对库（函数）进行编号和索引，以便于查找和检索。如图所示：

静态库的制作和使用:

文件格式:win下.lib、linux下 .a

1. linux下命名格式：

l 以lib开头

l 静态库名称xxx

l 以.a结尾

l 所以命名为libxxx.a

2静态库的描述:

l 优点: 寻址方便,速度快,库被打包到可执行程序中,直接发布可执行程序即可使用,无需附带静态库文件.a

l 静态库的代码在编译过程中已经被载入可执行程序,体积较大,如果静态函数被改变了,你的程序必须重新来进行编译

l 使用场合:在核心程序上使用,保证速度,可忽视空间,主流用于80,90时代,现在很少用

3．静态库的制作:

l 得到*.o的文件(编译成目标文件.o，带参数-c)

n 生成.o的文件

n gcc –c *.c //表示编译成二进制文件的库

l 得到静态库libxxx.a

n 打包ar rcs libxxx.a *.o -->打包.o的过程

u ar 工具不包含在gcc中

u r将文件转移到到静态库中

u c创建静态库,不管库是否存在

u s写入一个目标文件索引到库中,或者更新一个到一个存在的目标文件索引

n 查看库中符号,函数和全局变量等等,nm libxxx.a

l 静态库的使用:

n gcc + 源文件 + -L静态库路径 + -I静态库名 + -I头文件目录 + -o可执行文件名

u 例子:gcc xxx.c –L./lib -lxxx –I./include -o app

u -L 指定库所在的路径xxx/lib/*.a

u -I 指定库的名字xxx【由libxxx.a-->xxx】

l 去除前缀lib

l 去掉后缀.a

l 只留下中间部分

u -I 头文件目录位置-I(大写的i)xxx.h

n 注意：生成的静态库需要跟对应的头文件同时供别使用

n 头文件中存放的是函数接口(函数声明)

n gcc –c *.c –I./include

n ar rcs libxxx.a *.o

n nm libxxx.a

u nm libxxx.a 是查看静态库的名字,是可以查看这个静态库包含了几个静态.o文件

n 使用静态库,编译程序

u gcc app.c –o app –Iinclude – L lib –lxxx

u -L 库文件的路径名

u -l 插头去尾静态库的名字

动态库的制作和使用

l 使用场景:

n 共享库的代码是在可执行程序运行时才载入内存的,在编译过程中,简单的对函数引用,代码体积较小

n 优点:节省内存和易于更新(动态链接)

u 停止运行程序

u 使用新库覆盖旧库

u 重新启动程序

n 缺点:延时绑定,速度略慢

n 对速度要求不是很强烈的地方都应该使用动态库

n 动态库是否加载到了内存,取决于程序是否运行

l 命名格式: lib开头,静态库名称,.so结尾 àlibmytest.so

l 制作:

n 生成于位置无关的目标文件:gcc –fPIC *.c –c

u 参数-fPIC表示生成与位置无关代码

u 执行完毕后生成一系列的*.o文件

n 制作动态库 gcc –shared –o libxxx.so *.o

u 参数:-shared制作动态库

u -o:重命名生成的新文件

n 使用动态库gcc app.c –L,. –lxxx –l./ -o app

u -L指定库所在的路径

u 去掉前缀lib

u 去掉后缀.so

u -l头文件目录位置

n 执行生成的可执行文件

u ./app 运行失败

l 查看依赖的共享库:ldd app 发现libmytest找不到

l 没有给动态库链接器(ld-linux.so.2)制定好动态库libmytest.so的路径

l 解决方案:

n 1.临时设置:exportLD_LIBRARY_PATH=库路径,将当前目录加入环境变量,但是终端退出了就无效了

u LD_LIBRARY_PATH:作用:指定查找共享库(动态链接库)时除了默认路径之外的其他路径,该路径在默认路径之前查找

u 设置方法:export命令来设置值

u

n 2.永久设置:将上条写入家目录下的.bashrc文件中

n 3.粗暴设置:直接将libmytest.so拷贝到/usr/lib的目录下,不建议

n 4.将libmytest.so的所在绝对路径追加到/etc/ld.so.conf文件,使用sudo ldconfig –v更新

u 例如放到/usr/local/lib/或者/home/xxx/lib

u 每次更新库的时候都需要sudo ldconfig –v更新

n 5.建立软连接：

u ln -s /home/lib/xxx.so /usr/lib/xxx.so

u 生成动态库用gcc来完成，由于可能存在多个版本，因此通常指定版本号：

u $gcc -shared -Wl,-soname,libhello.so.1 -o libhello.so.1.0 hello.o

u 另外再建立两个符号连接：

u $ln -s libxxx.so.1.0 libxxx.so.1

u $ln -s libxxx.so.1 libxxx.so

u libxxxx.so.major.minors

u 其中，xxxx是库的名字，major是主版本号，minor 是次版本号

这样一个libxxx的动态连接库就生成了。最重要的是传gcc -shared 参数使其生成是动态库而不是普通执行程序。

Wl 表示后面的参数也就是-soname,libhello.so.1直接传给连接器ld进行处理。实际上，每一个库都有一个soname，当连接器发现它正在查找的程序库中有这样一个名称，连接器便会将soname嵌入连结中的二进制文件内，而不是它正在运行的实际文件名，在程序执行期间，程序会查找拥有 soname名字的文件，而不是库的文件名，换句话说，soname是库的区分标志。

这样做的目的主要是允许系统中多个版本的库文件共存，习惯上在命名库文件的时候通常与soname相同。

详解链接时搜索路径

l 静态库链接时搜索路径顺序：

n 1.ld去找gcc命令中的参数-L

n 2.再去找gcc的环境变量：LIBRARY_PATH

n 3.再找内定目录 /lib、/usr/lib、/usr/local/lib，不可能你在某个文件夹写个.c,就编译程序给你加载到，不同的目录万一有同名的怎么办。所以就让你自己指定嘛。

l 动态链接时搜索的路径

n 1.编译时目标代码指定的动态库搜索路径

n 2.环境变量LD_LIBRARY_PATH指定的动态库搜索路径

n 3.配置文件：/etc/ld.so.conf指定的动态库搜索路径

n 4.默认的动态库搜索路径/lib;

n 5.默认的动态库搜索路径:/usr/lib

u 有关环境变量
LIBRARY_PATH环境变量：指定程序静态链接库文件搜索路径
LD_LIBRARY_PATH环境变量：指定程序动态链接库文件搜索路径

找不到动态库解决方案

windows下，找不到动态库，直接报错：这是传课kk缺少动态库，一般网络上下载的软件，缺少某某动态库，直接搜索，下载后，放到系统目录就可以了。

多数在linux下安装完第三方库找不到动态库如何解决？

问题来源：安装完第三方库，直接运行第三方程序，会找不到第三方库文件？

tmux: error while loading shared libraries: libevent-1.4.so.2: cannot open shared object file: No such file or directory

原因一般有两个,一个是操作系统里确实没有包含该共享库(lib*.so.*文件)或者共享库版本不对,遇到这种情况那就去网上下载并安装上即可。

另外一个原因就是已经安装了该共享库,但执行需要调用该共享库的程序的时候,程序按照默认共享库路径找不到该共享库文件。的确是如此：

所以安装共享库后要注意共享库路径设置问题,如下:

1)如果共享库文件安装到了/lib或/usr/lib目录下,那么需执行一下ldconfig命令

sudo ldconfig –v

ldconfig命令的用途, 主要是在默认搜寻目录(/lib和/usr/lib)以及动态库配置文件/etc/ld.so.conf内所列的目录下, 搜索出可共享的动态链接库(格式如lib*.so*), 进而创建出动态装入程序(ld.so)所需的连接和缓存文件. 缓存文件默认为/etc/ld.so.cache, 此文件保存已排好序的动态链接库名字列表.

2) 如果共享库文件安装到了/usr/local/lib(很多开源的共享库都会安装到该目录下)或其它"非/lib或/usr/lib"目录下, 那么在执行ldconfig命令前, 还要把新共享库目录加入到共享库配置文件/etc/ld.so.conf中, 如下:

# cat /etc/ld.so.conf

include ld.so.conf.d/*.conf

# echo "/usr/local/lib" >> /etc/ld.so.conf

# ldconfig

3) 如果共享库文件安装到了其它"非/lib或/usr/lib" 目录下, 但是又不想在/etc/ld.so.conf中加路径(或者是没有权限加路径). 那可以export一个全局变量LD_LIBRARY_PATH, 然后运行程序的时候就会去这个目录中找共享库.

LD_LIBRARY_PATH的意思是告诉loader在哪些目录中可以找到共享库. 可以设置多个搜索目录, 这些目录之间用冒号分隔开. 比如安装了一个mysql到/usr/local/mysql目录下, 其中有一大堆库文件在/usr/local/mysql/lib下面, 则可以在.bashrc或.bash_profile或shell里加入以下语句即可:

export LD_LIBRARY_PATH=/usr/local/mysql/lib:$LD_LIBRARY_PATH

一般来讲这只是一种临时的解决方案, 在没有权限或临时需要的时候使用.

4）如果程序需要的库文件比系统目前存在的村文件版本低，可以做一个链接

比如：

error while loading shared libraries: libncurses.so.4: cannot open shared

object file: No such file or directory

ls /usr/lib/libncu*

/usr/lib/libncurses.a /usr/lib/libncurses.so.5

/usr/lib/libncurses.so /usr/lib/libncurses.so.5.3

可见虽然没有libncurses.so.4，但有libncurses.so.5，是可以向下兼容的

建一个链接就好了

ln -s /usr/lib/libncurses.so.5.3 /usr/lib/libncurses.so.4

注意的事情说三遍:

未定义的引用错误的原因和解决办法

每一次添加新的动态库,都需要刷新 ldconfig -v

ldconfig几个需要注意的地方:

-->往/lib和/usr/lib里面加东西，是不用修改/etc/ld.so.conf的，但是完了之后要调一下ldconfig，不然这个library会找不到

1..c文件包含头文件,需要 -I路径

./test/redis_test: error while loading shared libraries:

libhiredis.so.0.13: cannot open shared object file: No such file or directory

2.-l

-l参数就是用来指定程序要链接的库，-l参数紧接着就是库名，那么库名跟真正的库文件名有什么关系呢？他的库名是m，他的库文件名是libm.so，很容易看出，把库文件名的头lib和尾.so去掉就是库名了

放在/lib和/usr/lib和/usr/local/lib里的库直接用-l参数就能链接了-lxxx

比如常用的X11的库，它在/usr/X11R6/lib目录下，我们编译时就要用

3.-L

-L/usr/X11R6/lib -lX11参数，-L参数跟着的是库文件所在的目录名。再比如我们把libtest.so放在/aaa/bbb/ccc目录下，那链接参数就是-L/aaa/bbb/ccc -ltest

4.第三方库-->

就是说找不到动态库:

一般而言，有很多的so会存放在/usr/local/lib这个目录底下，去这个目录底下找，果然发现自己所需要的.so文件。

解决方案:

sudo vim /etc/ld.so.conf

添加 /usr/local/lib这一行

保存之后，再运行：/sbin/ldconfig –v

更新一下配置即可。

查看动态库依赖库

ldd命令：查看可执行程序依赖的共享库

例如:

Windows下创建与使用静态库

转自（http://blog.csdn.net/andy_93/article/details/52708678）

创建静态库（.lib）

如果是使用VS命令行生成静态库，也是分两个步骤来生成程序：

l 首先，通过使用带编译器选项 /c 的Cl.exe编译代码 (cl /c StaticMath.cpp)，创建名为“StaticMath.obj”的目标文件。

l 然后，使用库管理器 Lib.exe 链接代码 (lib StaticMath.obj)，创建静态库StaticMath.lib。

当然，我们一般不这么用，使用VS工程设置更方便。创建win32控制台程序时，勾选静态库类型；打开工程“属性面板”è”配置属性”è”常规”，配置类型选择静态库。

图：vs静态库项目属性设置

Build项目即可生成静态库。

使用静态库

测试代码Linux下面的一样。有3种使用方法：

方法一：

在VS中使用静态库方法：

l  工程“属性面板”è“通用属性”è “框架和引用”è”添加引用”，将显示“添加引用”对话框。 “项目”选项卡列出了当前解决方案中的各个项目以及可以引用的所有库。 在“项目”选项卡中，选择 StaticLibrary。单击“确定”。

l  添加StaticMath.h 头文件目录，必须修改包含目录路径。打开工程“属性面板”è”配置属性”è“C/C++”è” 常规”，在“附加包含目录”属性值中，键入StaticMath.h 头文件所在目录的路径或浏览至该目录。

编译运行OK。

图：静态库测试结果（vs）

如果引用的静态库不是在同一解决方案下的子工程，而是使用第三方提供的静态库lib和头文件，上面的方法设置不了。还有2中方法设置都可行。

方法2：打开工程“属性面板”è”配置属性”è “链接器”è”命令行”，输入静态库的完整路径即可。

方法三：

l  “属性面板”è”配置属性”è “链接器”è”常规”，附加依赖库目录中输入，静态库所在目录

“属性面板”è”配置属性”è “链接器”è”输入”，附加依赖库中输入静态库名StaticLibrary.lib。

动态库

通过上面的介绍发现静态库，容易使用和理解，也达到了代码复用的目的，那为什么还需要动态库呢？

为什么还需要动态库？

为什么需要动态库，其实也是静态库的特点导致。

l 空间浪费是静态库的一个问题。

l 另一个问题是静态库对程序的更新、部署和发布页会带来麻烦。如果静态库liba.lib更新了，所以使用它的应用程序都需要重新编译、发布给用户（对于玩家来说，可能是一个很小的改动，却导致整个程序重新下载，全量更新）。

动态库在程序编译时并不会被连接到目标代码中，而是在程序运行是才被载入。不同的应用程序如果调用相同的库，那么在内存里只需要有一份该共享库的实例，规避了空间浪费问题。动态库在程序运行是才被载入，也解决了静态库对程序的更新、部署和发布页会带来麻烦。用户只需要更新动态库即可，增量更新。

动态库特点总结：

l 动态库把对一些库函数的链接载入推迟到程序运行的时期。

l 可以实现进程之间的资源共享。（因此动态库也称为共享库）

l 将一些程序升级变得简单。

l 甚至可以真正做到链接载入完全由程序员在程序代码中控制（显示调用）。

Window与Linux执行文件格式不同，在创建动态库的时候有一些差异。

l 在Windows系统下的执行文件格式是PE格式，动态库需要一个DllMain函数做出初始化的入口，通常在导出函数的声明时需要有_declspec(dllexport)关键字。

l Linux下gcc编译的执行文件默认是ELF格式，不需要初始化入口，亦不需要函数做特别的声明，编写比较方便。

与创建静态库不同的是，不需要打包工具（ar、lib.exe），直接使用编译器即可创建动态库。

Linux下创建与使用动态库

linux动态库的命名规则

动态链接库的名字形式为 libxxx.so，前缀是lib，后缀名为“.so”。

l 针对于实际库文件，每个共享库都有个特殊的名字“soname”。在程序启动后，程序通过这个名字来告诉动态加载器该载入哪个共享库。

l 在文件系统中，soname仅是一个链接到实际动态库的链接。对于动态库而言，每个库实际上都有另一个名字给编译器来用。它是一个指向实际库镜像文件的链接文件（lib+soname+.so）。

创建动态库（.so）

编写四则运算动态库代码：

DynamicMath.h头文件

#pragma once

class DynamicMath

{

public:

        DynamicMath(void);

        ~DynamicMath(void);

        static double add(double a, double b);//¼Ó·¨

        static double sub(double a, double b);//¼õ·¨

        static double mul(double a, double b);//³Ë·¨

        static double div(double a, double b);//³ý·¨

        void print();

};

l 首先，生成目标文件，此时要加编译器选项-fpic

g++ -fPIC -c DynamicMath.cpp

-fPIC 创建与地址无关的编译程序（pic，position independent code），是为了能够在多个应用程序间共享。

l 然后，生成动态库，此时要加链接器选项-shared

g++ -shared -o libdynmath.so DynamicMath.o

-shared指定生成动态链接库。

其实上面两个步骤可以合并为一个命令：

g++ -fPIC -shared -o libdynmath.so DynamicMath.cpp

使用动态库

编写使用动态库的测试代码：

测试代码：

#include "../DynamicLibrary/DynamicMath.h"

#include <iostream>

using namespace std;

int main(int argc, char* argv[])

{

    double a = 10;

    double b = 2;

    cout << "a + b = " << DynamicMath::add(a, b) << endl;

    cout << "a - b = " << DynamicMath::sub(a, b) << endl;

    cout << "a * b = " << DynamicMath::mul(a, b) << endl;

    cout << "a / b = " << DynamicMath::div(a, b) << endl;

    DynamicMath dyn;

    dyn.print();

    return 0;

}

引用动态库编译成可执行文件（跟静态库方式一样）：

g++ TestDynamicLibrary.cpp -L../DynamicLibrary -ldynmath

然后运行：./a.out，发现竟然报错了！！！

可能大家会猜测，是因为动态库跟测试程序不是一个目录，那我们验证下是否如此：

发现还是报错！！！那么，在执行的时候是如何定位共享库文件的呢？

1) 当系统加载可执行代码时候，能够知道其所依赖的库的名字，但是还需要知道绝对路径。此时就需要系统动态载入器(dynamic linker/loader)。

2) 对于elf格式的可执行程序，是由ld-linux.so*来完成的，它先后搜索elf文件的 DT_RPATH段—环境变量LD_LIBRARY_PATH—/etc/ld.so.cache文件列表—/lib/,/usr/lib 目录找到库文件后将其载入内存。

如何让系统能够找到它：

l 如果安装在/lib或者/usr/lib下，那么ld默认能够找到，无需其他操作。

l 如果安装在其他目录，需要将其添加到/etc/ld.so.cache文件中，步骤如下：

n 编辑/etc/ld.so.conf文件，加入库文件所在目录的路径

n 运行ldconfig ，该命令会重建/etc/ld.so.cache文件

我们将创建的动态库复制到/usr/lib下面，然后运行测试程序。

Windows下创建与使用动态库

创建动态库（.dll）

与Linux相比，在Windows系统下创建动态库要稍微麻烦一些。首先，需要一个DllMain函数做出初始化的入口（创建win32控制台程序时，勾选DLL类型会自动生成这个文件）：

dllmain.cpp入口文件

// dllmain.cpp : Defines the entry point for the DLL application.

#include "stdafx.h"

BOOL APIENTRY DllMain( HMODULE hModule,

DWORD ul_reason_for_call,

LPVOID lpReserved

                     )

{

switch (ul_reason_for_call)

    {

case DLL_PROCESS_ATTACH:

case DLL_THREAD_ATTACH:

case DLL_THREAD_DETACH:

case DLL_PROCESS_DETACH:

break;

    }

return TRUE;

}

通常在导出函数的声明时需要有_declspec(dllexport)关键字：

DynamicMath.h头文件

#pragma once

class DynamicMath

{

public:

__declspec(dllexport) DynamicMath(void);

__declspec(dllexport) ~DynamicMath(void);

static __declspec(dllexport) double add(double a, double b);//加法

static __declspec(dllexport) double sub(double a, double b);//减法

static __declspec(dllexport) double mul(double a, double b);//乘法

static __declspec(dllexport) double div(double a, double b);//除法

__declspec(dllexport) void print();

};

生成动态库需要设置工程属性，打开工程“属性面板”è”配置属性”è”常规”，配置类型选择动态库。

图：v动态库项目属性设置

Build项目即可生成动态库。

使用动态库

创建win32控制台测试程序：

TestDynamicLibrary.cpp测试程序

#include "stdafx.h"

#include "DynamicMath.h"

#include <iostream>

using namespace std;

int _tmain(int argc, _TCHAR* argv[])

{

double a = 10;

double b = 2;

    cout << "a + b = " << DynamicMath::add(a, b) << endl;

    cout << "a - b = " << DynamicMath::sub(a, b) << endl;

    cout << "a * b = " << DynamicMath::mul(a, b) << endl;

    cout << "a / b = " << DynamicMath::div(a, b) << endl;

DynamicMath dyn;

    dyn.print();

    system("pause");

return 0;

}

方法一：

l 工程“属性面板”è“通用属性”è “框架和引用”è”添加引用”，将显示“添加引用”对话框。“项目”选项卡列出了当前解决方案中的各个项目以及可以引用的所有库。 在“项目”选项卡中，选择DynamicLibrary。 单击“确定”。

l 添加DynamicMath.h 头文件目录，必须修改包含目录路径。打开工程“属性面板”è”配置属性”è“C/C++”è” 常规”，在“附加包含目录”属性值中，键入DynamicMath.h 头文件所在目录的路径或浏览至该目录。

编译运行OK。

图：动态库测试结果（vs）

方法二：

l “属性面板”è”配置属性”è “链接器”è”常规”，附加依赖库目录中输入，动态库所在目录；

l “属性面板”è”配置属性”è “链接器”è”输入”，附加依赖库中输入动态库编译出来的DynamicLibrary.lib。

这里可能大家有个疑问，动态库怎么还有一个DynamicLibrary.lib文件？即无论是静态链接库还是动态链接库，最后都有lib文件，那么两者区别是什么呢？其实，两个是完全不一样的东西。

StaticLibrary.lib的大小为190KB，DynamicLibrary.lib的大小为3KB，静态库对应的lib文件叫静态库，动态库对应的lib文件叫【导入库】。实际上静态库本身就包含了实际执行代码、符号表等等，而对于导入库而言，其实际的执行代码位于动态库中，导入库只包含了地址符号表等，确保程序找到对应函数的一些基本地址信息。

动态库的显式调用

上面介绍的动态库使用方法和静态库类似属于隐式调用，编译的时候指定相应的库和查找路径。其实，动态库还可以显式调用。【在C语言中】，显示调用一个动态库轻而易举！

在Linux下显式调用动态库

#include <dlfcn.h>，提供了下面几个接口：

l void * dlopen( const char * pathname, int mode )：函数以指定模式打开指定的动态连接库文件，并返回一个句柄给调用进程。

l void* dlsym(void* handle,const char* symbol)：dlsym根据动态链接库操作句柄(pHandle)与符号(symbol)，返回符号对应的地址。使用这个函数不但可以获取函数地址，也可以获取变量地址。

l int dlclose (void *handle)：dlclose用于关闭指定句柄的动态链接库，只有当此动态链接库的使用计数为0时,才会真正被系统卸载。

l const char *dlerror(void)：当动态链接库操作函数执行失败时，dlerror可以返回出错信息，返回值为NULL时表示操作函数执行成功。

在Windows下显式调用动态库

应用程序必须进行函数调用以在运行时显式加载 DLL。为显式链接到 DLL，应用程序必须：

l 调用 LoadLibrary（或相似的函数）以加载 DLL 和获取模块句柄。

l 调用 GetProcAddress，以获取指向应用程序要调用的每个导出函数的函数指针。由于应用程序是通过指针调用 DLL 的函数，编译器不生成外部引用，故无需与导入库链接。

l 使用完 DLL 后调用 FreeLibrary。

显式调用C++动态库注意点

对C++来说，情况稍微复杂。显式加载一个C++动态库的困难一部分是因为C++的name mangling；另一部分是因为没有提供一个合适的API来装载类，在C++中，您可能要用到库中的一个类，而这需要创建该类的一个实例，这不容易做到。

name mangling可以通过extern "C"解决。C++有个特定的关键字用来声明采用C binding的函数：extern "C" 。用 extern "C"声明的函数将使用函数名作符号名，就像C函数一样。因此，只有非成员函数才能被声明为extern "C"，并且不能被重载。尽管限制多多，extern "C"函数还是非常有用，因为它们可以象C函数一样被dlopen动态加载。冠以extern "C"限定符后，并不意味着函数中无法使用C++代码了，相反，它仍然是一个完全的C++函数，可以使用任何C++特性和各种类型的参数。

另外如何从C++动态库中获取类，附上几篇相关文章，但我并不建议这么做：

l 《LoadLibrary调用DLL中的Class》：http://www.cppblog.com/codejie/archive/2009/09/24/97141.html

l 《C++ dlopen mini HOWTO》：http://blog.csdn.NET/denny_233/article/details/7255673

“显式”使用C++动态库中的Class是非常繁琐和危险的事情，因此能用“隐式”就不要用“显式”，能静态就不要用动态。

附件：Linux下库相关命令

g++(gcc)编译选项

l -shared ：指定生成动态链接库。

l -static ：指定生成静态链接库。

l -fPIC ：表示编译为位置独立的代码，用于编译共享库。目标文件需要创建成位置无关码， 念上就是在可执行程序装载它们的时候，它们可以放在可执行程序的内存里的任何地方。

l -L. ：表示要连接的库所在的目录。

l -l：指定链接时需要的动态库。编译器查找动态连接库时有隐含的命名规则，即在给出的名字前面加上lib，后面加上.a/.so来确定库的名称。

l -Wall ：生成所有警告信息。

l -ggdb ：此选项将尽可能的生成gdb 的可以使用的调试信息。

l -g ：编译器在编译的时候产生调试信息。

l -c ：只激活预处理、编译和汇编,也就是把程序做成目标文件(.o文件) 。

l -Wl,options ：把参数(options)传递给链接器ld 。如果options 中间有逗号,就将options分成多个选项,然后传递给链接程序。

nm命令

有时候可能需要查看一个库中到底有哪些函数，nm命令可以打印出库中的涉及到的所有符号。库既可以是静态的也可以是动态的。nm列出的符号有很多，常见的有三种：

l 一种是在库中被调用，但并没有在库中定义(表明需要其他库支持)，用U表示；

l 一种是库中定义的函数，用T表示，这是最常见的；

l 一种是所谓的弱态”符号，它们虽然在库中被定义，但是可能被其他库中的同名符号覆盖，用W表示。

$nm libhello.h

ldd命令

ldd命令可以查看一个可执行程序依赖的共享库，例如我们编写的四则运算动态库依赖下面这些库：

总结

二者的不同点在于代码被载入的时刻不同。

l 静态库在程序编译时会被连接到目标代码中，程序运行时将不再需要该静态库，因此体积较大。

l 动态库在程序编译时并不会被连接到目标代码中，而是在程序运行是才被载入，因此在程序运行时还需要动态库存在，因此代码体积较小。

动态库的好处是，不同的应用程序如果调用相同的库，那么在内存里只需要有一份该共享库的实例。带来好处的同时，也会有问题！如经典的DLL Hell问题，关于如何规避动态库管理问题，可以自行查找相关资料。