最近工作中遇到需要调用别人的动态链接库，但是只有个dll文件，别的一概没有，这可怎么办呢。还有不少dll导出的都是类，直接显式调用不太方便，最后综合网上的办法，自己再写两个工具，终于实现了将dll导出lib文件，并同时生成.h头文件。
    
    还是自己动手才能丰衣足食啊。

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

问题：如果手上只有一个DLL文件，没有lib文件.h头文件，程序里怎么调用它

方法当然很简单，
先用VC的工具Depends.exe查看导出函数的函数名啊
用IDAPro或者其他反汇编工具分析函数原型
再用API函数：LoadLibrary，GetProcAddress
完成！

但是……如果Dll导出的是一个个的类呢，这就稍微有点麻烦

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

方法1：还是用显式调用，LoadLibrary，GetProcAddress，
这时候就要在头文件里声明一个个的“类成员函数的函数指针”了，
把GetProcAddress返回值赋给这些指针，使用时调用指针即可。

如何知道类的成员函数原型是长什么样的呢？
还是Depends工具，如果直接看，会发现导出函数名中有好多"?","@"等符号，

Depends的上面有个按钮"C++"（如果没有这个按钮，说明你的Depends太老了，下载个新的吧），点了这个按钮，再看看函数名有啥变化，是不是变得比较好理解了
不过Depends解析得还不够完全，看不出来成员函数是public、protected还是private，也不知道调用约定是__cdecl、__stdcall还是__fastcall，是虚函数还是静态成员函数。
如果要知道这些，还是用VC的undname.exe看得比较全面。

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

方法2：用lib文件进行隐式链接，这样无需LoadLibrary，个人感觉比较方便的
如何生成lib文件呢，假设动态链接库名为example.dll，步骤如下

1、执行dumpbin.exe/EXPORTS example.dll>example.def
生成了一个def文件，里面的内容大概是下面这样：
   ordinal hint RVA      name
       1    0 00004570?function1@@
       2    1 00004540?function2@@

2、编辑这个def文件，删掉没用的信息，将它整理成这样的格式 ：
        LIBRARY "example"
        EXPORTS
        ?function1@@    @1
        ?function2@@    @2
上面的@1和@2是根据第1个步骤中的ordinal序号来的

这个步骤我写了个程序HandleDef.exe来自动修改，否则太多函数的话手动改就累死了

3、运行lib.exe/def:example.def
生成了example.lib和example.exp文件。这个lib文件就可以在VC里用了，
比如这样    #pragma comment(lib,"example.lib")

4、新建一个文件example.tmp，里面保存函数名
?function1@@
?function2@@
然后运行undname.exeexample.tmp>example.txt
这样函数名就解析到example.txt文件里了

5、自己写了个HandleTxt.exe程序，把example.txt转换为example.h
转换后变成类似下面这样：

1.       class __declspec(dllimport) CExample  

2.       {  

3.       public: int function1(void);  

4.       public: void function2(char);  

5.       };  

这个样子的基本就能直接拷到VC里用了。
不过，如果自己的程序要用到构造函数来新建一个对象的话，对导入类进行声明的时候要事先分析好类对象的内存分布（这可不是个简单的事啊），上面这个CExample类应该这样声明

1.       class __declspec(dllimport) CExample  

2.       {  

3.       public: int function1(void);  

4.       public: void function2(char);  

5.       public: BYTE m_data[256];  

6.       };  

//上面m_data具体多少个字节，要靠自己反汇编分析，没法自动生成，具体方法比较麻烦，有兴趣的可以去网上查一些C++类的反汇编资料。

==========================================
总结：
为了方便，把以下内容写到一个批处理文件中
set name=example

dumpbin.exe/EXPORTS %name%.dll>%name%.def
HandleDef.exe %name%.def
lib.exe /def:%name%.def /MACHINE:IX86
undname.exe %name%.tmp>%name%.txt
HandleTxt.exe %name%.txt

执行完之后生成lib文件和h文件。
=========================================

上面提到的HandleDef.exe和HandleTxt.exe是我自己用C#写的小程序。

写了这么多，也不知道有没有人会感兴趣。

注：我这个还只是适用于VC编写的dll导出的类

如果用extern"c"导出的函数，除了自己反汇编分析原型，貌似没有别的办法

如何调用非VC编译器编译出来的类，暂时未研究过。

 

下载地址：http://pan.baidu.com/netdisk/singlepublic?fid=795627_2574562052

 

头文件、lib 和 dll

三者的作用和联系

① 头文件的作用：声明函数接口

② lib 库有两种，

• 静态链接库（Static Library），索引和实现都在其中
• 动态链接库的导入库，此时 lib 只是一些索引信息，记录了 dll 中函数的入口和位置，dll 中是函数的具体内容

---

【Note】链接器怎么知道该调用哪个 DLL 文件呢？

这就是导入库文件的作用：告诉链接器调用的函数在哪个 DLL 中，函数执行代码在 DLL中 的什么位置

这也就是为什么需要在工程属性的『附加依赖项』中需要填入 lib 文件，它起到桥梁的作用。如果生成静态链接库文件，则没有 dll，只有 lib，这时函数可执行代码部分也放在 lib 文件中

---

③ dll 动态链接库的作用：含有函数的可执行代码。有两种加载方式，隐式链接（需要导入库）和显示连接（不需要导入库）

dll 一般会有对应的导入库，方便程序进行隐式链接加载，否则就需要 自己 LoadLibary 调入 dll 文件，然后再调用 GetProcAddress 获得对应函数（划线内容即显示链接加载 dll 方式）。有了导入库，我们只需要链接导入库后按照头文件函数接口的声明调用函数就可以了

④ 总结，

头文件是编译时必须的，lib 库是链接时需要的，dll 动态链接库是运行时需要的

如果要完成源代码的编译，只需要 lib；如果要使动态链接的程序运行起来，只需要 dll

三者的引入

① 添加工程的头文件目录

项目 → 属性 → 配置属性 → C/C++ → 常规 → 附加包含目录：加上头文件的存放目录

② 添加文件引用的 lib 静态库路径

项目 → 属性 → 配置属性 → 链接器 → 常规 → 附加库目录：加上lib文件的存放目录

③ 添加工程引用的 lib 文件名

项目 → 属性 → 配置属性 → 链接器 → 输入 → 附加依赖项：加上lib文件名

---

【Problem】LINK 2019

出现 LINK 2019 的错误，多半都是 lib 文件引入不正确上面的问题，检查链接器附加库目录和附加以依赖项是否正确配置

---

④ 添加对应的 dll

这个我建议用 everthing 搜一下当前工程下的 dll 文件都放在哪里，再把我们需要的 dll 文件拷进去就行

生成和使用 dll 文件

我们以一个简单加法例子来说明如何生成和使用 dll 文件，我们先创建一个 DLL 项目，取名作 Add，在该项目下面编写如下两个文件，add.h 文件和 add.cpp

// 下列 ifdef 块是创建使从 DLL 导出更简单的宏的标准方法
// 此 DLL 中的所有文件都是用命令行上定义的 ADD_EXPORTS 符号编译的
// 在使用此 DLL 的任何其他项目上不应定义此符号
// 这样，源文件中包含此文件的任何其他项目都会将
// ADD_API 函数视为是从 DLL 导入的,
// 而此 DLL 则将用此宏定义的符号视为是被导出的
#ifdef ADD_EXPORTS
#define ADD_API __declspec(dllexport)
#else
#define ADD_API __declspec(dllimport)
#endif

extern "C" ADD_API int add(int, int);   // 注意这里加上extern "C"，不然后面调用会出错 
										// ADD_API int add(int,int);

注意上面代码中的 extern "C"，虽然在源代码 add.cpp 中定义的函数名是 add，但在 dll 的二进制文件中，经过编译器的加工，它实际上变成另外一个名称。这个另外的名称在原有函数名 add 的基础上加上了一些函数输入输出参数的信息，这样做主要是为函数重载服务的，所以如果直接这样调用 dll，程序就会一直提示找不到 dll，因为函数名不匹配，解决方法有两种，

• 一是运用 extern "C" 修饰 add，就像我们上面那样
• 二是运用模块定义文件.def

---

【Note】为什么要加 extern "C"

详细可以参考这篇博客 C++调用C函数，为什么要加extern “C”?

---

我们的 add.cpp 文件为

// add.cpp : 定义 DLL 应用程序的导出函数
#define ADD_EXPORTS
#include "add.h"
//#include <stdafx.h>

// 这是导出函数的一个示例
ADD_API int add(int x, int y)
{
	int sum = x + y;
	return sum;
}

然后不着急点调试项目，在资源管理器中右键我们的 Add 项目，点击生成，如果成功，Add.lib 和 Add.dll 文件就创建好了

---

【Problem】提示 dll 不是有效的win32应用程序

调试 dll 应该附加到一个 exe 进程中，我们现在还没有 exe 程序，自然会报错

---

【Problem】在查找预编译头时遇到意外的文件结尾。是否忘记了向源中添加 #include “pch.h”

解决方法 参考这里

---

隐式调用

接着，我们在同一个解决方案下面新建一个项目 UseAddDll_Implicit，创建的是控制台引用程序，然后在 UseAddDll_Implicit.cpp 文件里编写如下代码

#include <iostream>
#include "add.h"
using namespace std;

int main()
{
	int x, y, sum;
	cin >> x >> y;
	sum = add(x, y);
	cout << sum << endl;
}

这时候会发现找不到 add.h 文件，这是正常的，因为我们还没有调用 dll

将 add.h 文件和 Add.lib、Add.dll 复制到 UseAddDll_Implicit 对应的工程文件夹里面，然后再在工程的属性中添加 lib 文件，不会添加 lib 文件的可以参照下面关于错误的解决方法

---

【Problem】文件无效或损坏无法在 0x379 处读取

问题发生原因：链接器→输入→附加依赖项，这里面应该是 lib 文件，但错误填写了 dll 文件

---

显示调用

我们还是在同一个解决方案下面新建一个项目 UseAddDll_Explicit，创建的是控制台引用程序，然后把 Add.dll 文件拷到新项目的文件下，再在 UseAddDll_Explicit.cpp 文件里编写如下代码

#include <Windows.h>
#include <iostream>
// Define a function pointer
typedef int(*FUNA)(int, int);

using namespace std;

int main()
{
	const char* dllName = "Add.dll";
	const char* funName = "add";
	HMODULE hDLL = LoadLibrary(dllName);
	if (hDLL != NULL)
	{
		FUNA fp1 = FUNA(GetProcAddress(hDLL, funName));
		if (fp1 != NULL)
		{
			int x, y, sum;
			cin >> x >> y;
			sum = fp1(x, y);
			cout << sum << endl;
		}
		else
		{
			cout << "Func add cannot be found." << endl;
		}
		FreeLibrary(hDLL);
	}
	else
	{
		cout << "Add.dll cannot be loaded." << endl;
	}

}

说明两点，

• LoadLibrary、FreeLibrary、GetProcAddress 等都是 Win32 API 函数，包含在头文件 Windows.h 中
• 当程序不再使用 dll 时，应及时调用 FreeLibrary 释放占用的内存空间

---

【Problem】const char* 类型的实参与 LTCWSTR 类型的形参不兼容

解决方法 参考这里

---

dll 导出函数名称规范化

我们可以使用 VS 自带的 dumpbin 工具查看 dll

在 VS 界面里面去找工具，然后在命令行里面找到开发者 PowerShell，打开后输入下面命令 dumpbin /exports ./Debug/Add.dll，接着我们可以下面的内容

当然在前面部分我们已经使用过 extern "C" 来修饰函数，如果不的话，我们将会看到下面这种的函数名

不使用 extern "C" 时 add.h 和 add.cpp 文件编写如下

#ifdef ADD_EXPORTS
#define ADD_API __declspec(dllexport)
#else
#define ADD_API __declspec(dllimport)
#endif

ADD_API int add(int, int);   // 注意这里没有使用 extern "C"

// add.cpp : 定义 DLL 应用程序的导出函数
#define ADD_EXPORTS
#include "add.h"
//#include <stdafx.h>

// 这是导出函数的一个示例
ADD_API int add(int x, int y)
{
	int sum = x + y;
	return sum;
}

这种输出相当不友好，会为 dll 的使用带来很多不便，例如在 LINK2019 的错误出现时，就会出现这种情况。所以，我们希望采用一定的方式使导出的函数修饰名称规范一些

当然 extern "C" 就是一种方法，还有一种是运用模块定义文件 def，这种方法的效果更好

我们在 Add 工程中添加一个 Source.def 文件，文件中编写如下的内容

LIBRARY Add
EXPORTS
add = ?add@@YAHHH@Z

然后再用 dumpbin 查看，结果发现函数名成功的被我们修改了

但是，我们还发现那个奇怪的函数名还是存在，这时可以修改 Add.h，将 #define ADD_API __declspec(dllexport) 修改为 #define ADD_API，这时的结果就比较满意了

生成和使用 lib 文件

我们新建一个静态库项目，取名为 AddLib，静态库项目没有 main 函数，也没有像动态链接库中的 dllmain.cpp 文件，创建完项目后自己添加 addlib.h 和 addlib.cpp 文件

#ifndef _MYLIB_H_
#define _MYLIB_H_

extern "C" int add(int, int);

#endif

#include "addlib.h"
#include <iostream>

int add(int x, int y)
{
	int sum = x + y;
	return sum;
}

调用 lib

调用静态库需要使用头文件和 lib 文件

同样我们还是新建一个工程，然后 将头文件和 lib 文件拷贝到新建的工程目录下面，然后再配置链接器的附加依赖项（或者直接在源代码中加入 #pragma comment(lib, "addlib.lib")），在源文件中添加 addlib.h，然后就可以在 UseAddLib.cpp 文件中调用 lib 了

#include "addlib.h"
#include <iostream>

using namespace std;

int main()
{
	int x, y, sum;
	cin >> x >> y;
	sum = add(x, y);
	cout << sum;
}

---

【Note】将现有的项目文件添加到另外一个项目中

我们可以将现有的项目文件拷贝到新的项目文件夹中，然后在 VS 的资源管理器中点击显示所有文件，之后右键点击拷贝过来的文件，选择包含到项目中，这样就好了

我们可以通过次方法将 addlib.h 文件引入到 UseAddLib 工程里面，当然也可以新建一个头文件，然后将代码复制过来

---

【By the way】哪里去找生成的 lib 文件

---

生成和使用 exe 文件

如果当前项目调试通过，那么 VS 本身就会在当前工程目录的 Debug 文件夹下生成 exe可执行文件，非常方便

为什么要使用 dll

代码复用是提高软件开发 效率的重要途径。一般而言，只要某部分代码具有通用性，就可将它构造成相对独立的功能模块并在之后的项目中重复使用

『白盒复用』：像是 ATL、MFC等许多应用程序框架，它们都以源代码的形式发布。由于这种复用是源码级别的，源代码完全暴露给了程序员，因而称之为白盒复用

白盒复用的缺点 比较多，总结起来有4点，

• 暴露了源代码
• 容易与程序员的普通代码发生命名冲突
• 多份拷贝，造成存储浪费
• 更新功能模块比较困难

实际上，以上四点概括起来就是，暴露的源代码造成代码严重耦合。为了弥补这些不足，就提出了 『二进制级别』 的代码复用。使用二进制级别的代码复用一定程度上隐藏了源代码，对于缓解代码耦合现象起到了一定的作用。这样的复用被称为 『黑盒复用』

在 Windows 系统中有两种可执行文件，其后缀名分别为 .exe 和 .dll

它们的区别在于，.exe 文件可被独立的装载于内存中运行；而 .dll 文件却不能，它只能被其它进程调用。然而无论什么格式，它们都是二进制文件。上面说到的二进制级别的代码复用，就可以使用 .dll 来实现

与白盒复用相 比，dll 很大程度上弥补了上的几个缺陷，

• dll 是二进制文件，因此隐藏了源代码
• 如果采用显式调用，一般不会发生命名冲突
• 由于 dll 是动态链接到应用程序中去的，它并不会在链接生成程序时原原本本拷贝进去
• 最后，dll 文件相对独立的存在，因此更新功能模块是可行的

当然，实现黑盒复用的途径不只 dll 一种，静态链接库甚至更高级的 COM 组件都是

动态链接库虽然一定程度上实现了黑盒复用，但仍存在着诸多不足，例如

• dll 节省了编译期的时间，但相应延长了运行期的时间，因为在使用 dll 的导出函数时，不但要加载 dll，而且程序将会在模块间跳转，降低了 cache 的命中率
• 若采用隐式调用，仍然需要头文件、lib 文件和 dll 文件三件套，并不能支持完全高效模块的更新
• 显式调用虽然很好地支持模块的更新，但却不能导出类和变量。
• dll 不支持 template

二进制级别的代码复用相比源码级别的复用已经有了很大的进步，但在二进制级别的代码复用中，dll 显得太古老。想真正完美实现跨平台、跨语言的黑盒复用，采用 COM 才是真正正确的选择

.h头文件是编译时必须的，lib是链接时需要的，dll是运行时需要的。

附加依赖项的是.lib不是.dll，若生成了DLL,则肯定也生成 LIB文件。如果要完成源代码的编译和链接，有头文件和lib就够了。如果也使动态连接的程序运行起来，有dll就够了（放在Debug文件夹里）。在开发和调试阶段，当然最好都有。

.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文件必须随应用程序一起发行，否则应用程序将会产生错误。

-------------------------------------------------------------------------------------
静态链接库(Lib)与动态链接库(DLL)的区别

     静态连接库就是把(lib)文件中用到的函数代码直接链接进目标程序，程序运行的时候不再需要其它的库文件；动态链接就是把调用的函数所在文件模块（DLL）和调用函数在文件中的位置等信息链接进目标程序，程序运行的时候再从DLL中寻找相应函数代码，因此需要相应DLL文件的支持。

静态链接库与动态链接库都是共享代码的方式，如果采用静态链接库，则无论你愿不愿意，lib 中的指令都全部被直接包含在最终生成的 EXE 文件中了。但是若使用 DLL，该 DLL 不必被包含在最终 EXE 文件中，EXE 文件执行时可以“动态”地引用和卸载这个与 EXE 独立的 DLL 文件。静态链接库和动态链接库的另外一个区别在于静态链接库中不能再包含其他的动态链接库或者静态库，而在动态链接库中还可以再包含其他的动态或静态链接库。


“每一个lib文件就是若干函数（假设只有函数）的定义”
lib库有两种，一种是包含了函数所在DLL文件和文件中函数位置的信息，称为导出库；一种是包含函数代码本身，一般现有的DLL，用的是前一种库；以前在DOS下的TC/BC等，是后一种库。包含函数原型声明的，是头文件（.h）。

“通过#include包含这些函数声明的头文件后，我们的应用程序就可以使用lib文件中的函数”

还要指定编译器链接相应的库文件。在IDE环境下，一般是一次指定所有用到的库文件，编译器自己寻找每个模块需要的库；在命令行编译环境下，需要指定每个模块调用的库。

“那他和直接给出那个函数定义的文件，比如.cpp文件，和头文件有什么区别，静态链接库有什么用”
cpp文件是源代码，库文件是编译后的二进制代码，比如你可以调用Windows的API，但是不能看到其源代码一样。

“还有不明白的是，静态链接库中的lib文件只要用到，则整个lib文件的内容都放进了exe文件中，那它是被编译进去还是链接的时候连接进去的呢?”
是在链接的时候将lib链接到目标代码中。

静态链接库(Lib)
在VC++6.0中new一个名称为libTest的static library工程，

并新建lib.h和lib.cpp两个文件，lib.h和lib.cpp的源代码如下：

//文件：lib.h
#ifndef LIB_H
#define LIB_H
extern "C" int add(int x,int y);　　　//声明为C编译、连接方式的外部函数
#endif

//文件：lib.cpp
#include "lib.h"
int add(int x,int y)
{
return x + y;
}


　　编译这个工程就得到了一个.lib文件，这个文件就是一个函数库，它提供了add的功能。将头文件和.lib文件提交给用户后，用户就可以直接使用其中的add函数了。

　　标准Turbo C2.0中的C库函数（我们用来的scanf、printf、memcpy、strcpy等）就来自这种静态库。

下面来看看怎么使用这个库，在libTest工程所在的工作区内new一个libCall工程。libCall工程仅包含一个main.cpp文件，它演示了静态链接库的调用方法，其源代码如下：

#include <stdio.h>
#include "..\lib.h"//不可丢失
#pragma comment( lib, "..\\debug\\libTest.lib" ) 　//指定与静态库一起连接
int main(int argc, char* argv[])
{
     printf( "2 + 3 = %d", add( 2, 3 ) );
}
　　静态链接库的调用就是这么简单，或许我们每天都在用，可是我们没有明白这个概念。代码中#pragma comment( lib , "..\\debug\\libTest.lib" )的意思是指本文件生成的.obj文件应与libTest.lib一起连接

-------------------------------------------------------------------------------------------
用VC++生成静态库文件
今天闲着没事做,自己写了一点小笔记,不知道对于新手有没用,高手就不用看了,作为新手的我斗胆来发表一个笔记,就是静态库文件的封装过程,使用VC++6.0编写,下面是正文,也许我的用语并不专业

以前我们写C/C++源文件的时候，都是先将各个写好的源文件编译，编译生成的是目标文件机器码，即.obj文件.（目标文件的扩展名不一定是.obj文件）.

我们调用的标准C/C++函数机器码实际被封装于标准C/C++静态库文件中的.即那些扩展名为.lib的文件中.

最后链接器将我们编译的各个目标文件里的机器码和静态库（标准C/C++库）中的函数机器码链接到一起形成一个扩展名为.exe的可执行文件模块.

在这里我们叙述将C/C++源文件编译链接成一个静态库文件，但它不是可执行模块，它体内含有可执行机器码

静态库文件就像一个仓库或者容器，里面封装了一些可执行机器码.这些机器码是我们用程序设计语言，比如C/C++源文件编译后生成的机器码.

一.下面将讨论将C/C++源文件编译并链接成一个静态库文件的过程，

在VC++6.0中选择File-New-Win32 Static Library，写好工程名创建好工作空间后再选择菜单中New-File来为工程添加C或者C++ 源文件.

假如我们为该工程添加了一个名为lib_c.c和一个名为lib_cpp.cpp的源文件

//lib_c.c中的内容

extern int Add(int x,int y) //该函数是一个外部函数，任何文件都可以访问它

{
　　　　return x+y;

}

extern int data_c
//这是一个外部全局变量，任何文件可以访问它

//lib_cpp.cpp中的内容

extern “C” int
        reduce(int x,int y)//这里加了个”C”表示允许C源文件访问这个C++函数代码

{
　　　　return x-y;

}

extern “C” int data_cpp=2;

注意以下几点

(1)当“extern”关键字修饰在函数或全局变量的定义中时，表示该函数或全局变量任何文件可以访问，“extern”关键字可以省略不写，缺省下就是”extern”

  当“extern”关键字修饰在函数声明或全局变量声明中时，表示限定当前文件只能引用用“extern”关键字修饰定义的函数或全局变量.

(2)当”static”关键字修饰在函数或全局变量的定义中时，表示该函数或全局变量只能由本文件中加了”static”关键字修饰的函数声明或全局变量声明来引用.

  当”static”关键字修饰在函数声明或全局变量声明中时，表示限定当前文件只能引用用“static”关键字修饰定义的函数或全局变量.

(3)在CPP源文件的函数和全局变量定义中加了个”C”表示允许C源文件访问该函数和全局变量.如果是C++源文件访它们的话则可加可不加.注意这”C”要大写.

接下来就要将写好的C/C++源文件进行编译和链接，最后会生成一个扩展名为.lib的文件.该文件就是静态库文件了，该静态库文件是不能直接运行的，我们所编译的C/C++源文件的机器码就已经被封装进这个用VC++6.0创建的静态库文件里面去了.

二.如何将编写好的静态库文件像使用C/C++标准库那样使用，下面将继续讨论

1.用VC++6.0新建一个工程名为TEST，添加一个名为TEST.c的源文件到该工程，因为我们将测试一下，将我们编写的库文件里的函数或者全局变量的机器码链接到我们这个TEST.c源文件中去，假设我们生成的库文件名为TEST.lib,先拷贝如下范例代码到TEST.c中

//TEST.c

#include <stdio.h>

extern int
Add(int x,int y); //当前文件只能访问“extern”关键字修饰定义的Add函数

extern int
reduce(int x,int y);// //当前文件只能访问“extern”关键字修饰定义的reduce函数

#pragma comment(lib,"TEST.lib") //指示链接器到字符串所表示的文件路径中去找库文件

int main()

{
　　　　printf("%d\n",Add(2,3));
　　　　printf("%d\n",reduce(3,2));
　　　　return 0;

}

这里我们要声明静态库中已知的函数或全局变量的声明

#pragma comment(lib,"TEST.lib")这条指令告诉链接器到字符串所表示的路径下去找库文件，这里我将库文件放到了当前工程目录下.也可以不写这句.

还有一种方法，可以直接在VC++6.0中设置依次选择tools、options、directories、library files菜单或选项，填入库文件路径（只键入库文件所在目录路径而不能输入库文件名），这只是告诉链接器库文件所在目录的路径，还没告诉链接器库文件名，方法是VC++6.0中设置依次选择project-settings-link 在object/library modules: 这栏输入库文件名字然后就OK了

2.当用C++源文件的目标文件和库文件的代码链接时有一点小改变，这里就不浪费口舌了，假设我们新建了一个工程并添加了一个名为TEST.CPP的源文件，拷贝如下范例代码到TEST.CPP中

//TEST.cpp

#include <stdio.h>

extern “C” int
       Add(int x,int y); //表示引用的是C函数代码

extern int
      reduce(int x,int y);

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

int main()

{
　　　　printf("%d\n",Add(2,3));
　　　　printf("%d\n",reduce(3,2));
　　　　return 0;

}

在这个C++源文件里引用C函数代码同样要加个”C”,但是在C源文件引用C++函数代码不能加”C++”,编译会报错，只能在C++文件函数定义中加”C”.

只有C++才支持这种引用方式，也许因为只有C++兼容C而没有C兼容C++这一原则.

.h用于编译阶段的审核，如在math.h中有函数声明：
int abs(int);
但是在使用中写为
#include <math.h>
...abs(3,5);
编译器阶段就会检测出错误。

.dll用于运行阶段，如调用SetWindowText()函数等，需要在user32.dll中找到该函数。DLL可以简单认为是一种包含供别人调用的函数和资源的可执行文件。

.lib用于链接阶段，在链接各部分目标文件（通常为.obj）到可执行文件（通常为.exe）过程中，需要在.lib文件中查找动态调用函数（一般为DLL中的函数）的地址信息，此时需要在lib文件中查找，如查找SetWindowText()函数的地址偏移就需要查找user32.lib文件。（.lib也可用于静态链接的内嵌代码）

 

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这些系统公用的目录中，系统中的任何用户都可以利用这些库。当然用户也可以建立自己专用的库函数，供自己或其它指定的人员使用。    
   
  　　库可以有三种使用的形式：静态、共享和动态。静态库的代码在编译时就已连接到开发人员开发的应用程序中，而共享库只是在程序开始运行时才载入，在编译时，只是简单地指定需要使用的库函数。动态库则是共享库的另一种变化形式。动态库也是在程序运行时载入，但与共享库不同的是，使用的库函数不是在程序运行开始，而是在程序中的语句需要使用该函数时才载入。动态库可以在程序运行期间释放动态库所占用的内存，腾出空间供其它程序使用。由于共享库和动态库并没有在程序中包括库函数的内容，只是包含了对库函数的引用，因此代码的规模比较小。

 

lib是静态库，dll一般是动态链接库（也有可能是别的）

比如要编译个exe，lib在编译的时候就会被编译到exe里，作为程序的一部分

而dll是不被编译进去，是运行的时候才调入的（可能是exe刚运行就调入，也可能运行了一半才调入）

用法，lib需要个.lib文件和一个.h文件，程序正常使用.h的函数，在链接选项里加入.lib文件就ok

dll用法有2种，一是 .h + .lib + .dll的，用法和前面一样，中间的lib是个中转，运行的时候会调用dll
二是：直接用dll，需要知道dll的函数定义，用LoadLibrary和GetProcAddress把函数指针取出来，看msdn的例子吧