2501,编写dll

`DLL`的优点

简单的说,dll有以下几个优点:

1)节省内存.同一个软件模块,若是源码重用,则会在不同可执行程序中编译,同时运行这些exe时,会在内存中重复加载这些模块的二进制码.

如果使用dll,则只在内存中加载一次,所有使用该dll的进程会共享此块内存(当然,每个进程会复制一份的dll中的全局变量).

2)不需编译的软件系统升级,若一个软件系统使用了dll,则改变该dll(函数名不变)时,系统升级只需要切换此dll即可,不需要重新编译整个系统.

3)多种语言可使用Dll库,如用c编写的dll可在vb中调用.DLL还做得很不够,因此在dll的基础上发明了COM技术,更好的解决了一系列问题.

最简单的`dll`

最简单的dll并不比c的helloworld难,只要一个DllMain函数即可,包含objbase.h头文件(支持COM技术的一个头文件).

若该头文件名字难记,则用windows.h也可以.源码如下:dll_nolib.cpp

#include <objbase.h>
#include <iostream.h>
BOOL APIENTRY DllMain(HANDLE hModule, DWORD dwReason, void* lpReserved)
{HANDLE g_hModule;switch(dwReason){case DLL_PROCESS_ATTACH:cout<<"Dll is attached!"<<endl;g_hModule = (HINSTANCE)hModule;break;case DLL_PROCESS_DETACH:cout<<"Dll is detached!"<<endl;g_hModule=NULL;break;}return true;
}

其中DllMain是每个dll的入口函数,如同c的主函数一样.DllMain带三个参数,hModule表示本dll的实例句柄,dwReason表示dll当前所处的状态,如DLL_PROCESS_ATTACH表示dll刚刚被加载到一个进程中,DLL_PROCESS_DETACH表示刚刚从一个进程中卸载dll.

当然还有表示加载到线程中和从线程中卸载的状态,这里省略.最后参数是一个保存参数.

如上,在一个进程中加载dll时,dll打印"Dllisattached!"语句;当从进程中卸载dll时,打印"Dllisdetached!"语句.

编译dll需要以下两条命令:

cl /c dll_nolib.cpp

这条命令会按obj文件编译cpp,若不使用/c参数,则cl还会继续链接obj为exe,但是这里是一个dll,没有主函数,因此会报错.不要紧,继续使用链接命令.

Link /dll dll_nolib.obj

这条命令会生成dll_nolib.dll.

加载`DLL`(显式调用)

一般有两个方式使用dll,显式调用和隐式调用.这里首先介绍显式调用.编写一个客户程序:dll_nolib_client.cpp

#include <windows.h>
#include <iostream.h>
int main(void)
{//加载的`dll`HINSTANCE hinst=::LoadLibrary("dll_nolib.dll");if (NULL != hinst){cout<<"dll loaded!"<<endl;}return 0;
}

注意,调用dll使用LoadLibrary函数,它的参数就是dll的路径和名字,返回值是dll的句柄.使用如下命令编译链接客户:

Cl dll_nolib_client.cpp

并执行dll_nolib_client.exe,得到如下结果:
Dllisattached!
dllloaded!
Dllisdetached!

以上结果表明客户已加载dll.但是这样仅可在内存加载dll,不能找到dll中的函数.

使用`dumpbin`命令查看`DLL`中的函数

Dumpbin命令可查看一个dll中的输出函数符号名,输入如下命令:

Dumpbin -exports dll_nolib.dll

查看发现dll_nolib.dll并没有输出函数.

如何在`dll`中定义输出函数

总体来说有两个方法,一个是添加一个def定义文件,在此文件中定义dll中要输出的函数;第二个是在源码中,待输出的函数前加上__declspec(dllexport)关键字.

`Def`文件

首先写一个带输出函数的dll,源码如下:dll_def.cpp

#include <objbase.h>
#include <iostream.h>
void FuncInDll (void)
{cout<<"FuncInDll is called!"<<endl;
}
BOOL APIENTRY DllMain(HANDLE hModule, DWORD dwReason, void* lpReserved)
{HANDLE g_hModule;switch(dwReason){case DLL_PROCESS_ATTACH:g_hModule = (HINSTANCE)hModule;break;case DLL_PROCESS_DETACH:g_hModule=NULL;break;}return TRUE;
}

该dll的def文件如下:dll_def.def

;
//`dll_def`模块定义文件
;
LIBRARY         dll_def.dll
DESCRIPTION     '(c)2007-2009 Wang Xuebin'
EXPORTSFuncInDll @1 PRIVATE

def的语法很简单,首先是库关键字,指定dll的名字;然后一个可选的描述关键字.

最后是导出关键字,后面写上dll中所有要输出的函数名或变量名,然后接上@及依次编号的数字(从1到N),最后接上修饰符.

用如下命令编译链接带def文件的dll:

Cl /c dll_def.cpp
Link /dll dll_def.obj /def:dll_def.def

再调用dumpbin查看生成的dll_def.dll:

Dumpbin -exports dll_def.dll

得到结果.
观察这一行.
1000001000FuncInDll
会发现该dll输出了FuncInDll函数.

显式调用`DLL`中的函数

写一个dll_def.dll的客户程序:dll_def_client.cpp

#include <windows.h>
#include <iostream.h>
int main(void)
{//定义一个函数指针typedef void (* DLLWITHLIB )(void);//定义一个函数指针变量DLLWITHLIB pfFuncInDll = NULL;//加载`dll`HINSTANCE hinst=::LoadLibrary("dll_def.dll");if (NULL != hinst){cout<<"dll loaded!"<<endl;}//找到`dll`的`FuncInDll`函数pfFuncInDll = (DLLWITHLIB)GetProcAddress(hinst, "FuncInDll");//调用`dll`里的函数if (NULL != pfFuncInDll){(*pfFuncInDll)();}return 0;
}

有两个地方值得注意,第一是定义和使用函数指针;第二是使用GetProcAddress,来查找dll中的函数地址.
第一个参数是DLL的句柄,即LoadLibrary返回的句柄,第二个参数是dll中的函数名,即dumpbin中输出的函数名.
注意,这里的函数名指的是编译后的函数名,不一定等于dll源码中的函数名.

编译链接该客户程序,执行得到:
dllloaded!
FuncInDlliscalled!

即客户成功调用了dll中的FuncInDll函数.

__declspec(dllexport)

为每个dll写def显得很麻烦,当前def使用已比较少了,更多的是在源码中,使用__declspec(dllexport)定义dll的输出函数.

Dll写法同上,去掉def文件,并在每个要输出的函数前面加上__declspec(dllexport)声明,如:

__declspec(dllexport) void FuncInDll (void)

这里提供一个dll的dll_withlib.cpp源程序,然后编译链接.链接时不需要指定/DEF:参数,直接加/DLL参数即可,

Cl /c dll_withlib.cpp
Link /dll dll_withlib.obj

然后使用dumpbin命令查看,得到:

1    0 00001000  FuncInDll@@YAXXZ

可知编译后的函数名为FuncInDll@@YAXXZ.
可用extern"C"指令来命令c++编译器按c编译器的方式来命名该函数.如下:

extern "C" __declspec(dllexport) void FuncInDll (void)

dumpbin命令结果:
1000001000 FuncInDll
这样,显式调用时只需查找函数名为FuncInDll的函数即可成功.

隐式调用`DLL`

显式调用显得非常复杂,每次都要LoadLibrary,并且每个函数都必须使用GetProcAddress来得到函数指针,对大量使用dll函数的客户是个困扰.

而隐式调用可像使用c函数库一样使用dll中的函数,非常方便快捷.

下面是一个隐式调用的示例:dll包含两个文件dll_withlibAndH.cpp和dll_withlibAndH.h.
代码如下:dll_withlibAndH.h

extern "C" __declspec(dllexport) void FuncInDll (void);
//dll_withlibAndH.cpp
#include <objbase.h>
#include <iostream.h>
#include "dll_withLibAndH.h"//看到没有,这就是增加的头文件
extern "C" __declspec(dllexport) void FuncInDll (void)
{cout<<"FuncInDll is called!"<<endl;
}
BOOL APIENTRY DllMain(HANDLE hModule, DWORD dwReason, void* lpReserved)
{HANDLE g_hModule;switch(dwReason){case DLL_PROCESS_ATTACH:g_hModule = (HINSTANCE)hModule;break;case DLL_PROCESS_DETACH:g_hModule=NULL;break;}return TRUE;
}

编译链接命令:

Cl /c dll_withlibAndH.cpp
Link /dll dll_withlibAndH.obj

在隐式调用时,需要在客户中引入头文件,并在链接时指明dll对应的lib文件(dll只要有函数输出,则链接时会产生一个与dll同名的lib文件)位置和名.

然后如同调用api函数库中的函数一样调用dll中的函数,不需要显式的LoadLibrary和GetProcAddress.使用最方便.

客户代码如下:dll_withlibAndH_client.cpp

#include "dll_withLibAndH.h"
//注意路径,加载`dll`的或`项目`|设置|`链接`设置里
#pragma comment(lib,"dll_withLibAndH.lib")
int main(void)
{FuncInDll();//只要这样就可调用`dll`里的函数了return 0;
}

`declspec(dllexport)`和`declspec(dllimport`)配对使用

事实上不使用extern"C"是可行的,这时会按c++的符号串编译函数,如(FuncInDll@@YAXH@Z,FuncInDll@@YAXXZ),当客户也是c++时,也能正确的隐式调用.

这时要考虑一种情况:若DLL1.CPP是源,DLL2.CPP使用了DLL1中的函数,但同时DLL2也是一个DLL,也要输出一些函数供Client.CPP使用.

则在DLL2中如何声明所有的,既包含了从DLL1中引入的函数,还包括自己要输出的函数的函数.此时就需要同时使用__declspec(dllexport)和__declspec(dllimport)了.

前者用来装饰本dll中的输出函数,后者用来装饰从其它dll中引入的函数.

所有的源码包括DLL1.H,DLL1.CPP,DLL2.H,DLL2.CPP,Client.cpp.
值得关注的是DLL1和DLL2中都使用的一个编码方法,见DLL2.H

#ifdef DLL_DLL2_EXPORTS
#define DLL_DLL2_API __declspec(dllexport)
#else
#define DLL_DLL2_API __declspec(dllimport)
#endif
DLL_DLL2_API void FuncInDll2(void);
DLL_DLL2_API void FuncInDll2(int);

在头文件中这样定义DLL_DLL2_EXPORTS和DLL_DLL2_API宏,可确保DLL端的函数用__declspec(dllexport)装饰,而客户的函数用__declspec(dllimport)装饰.

当然,记得在编译dll时加上参数/D "DLL_DLL2_EXPORTS",或干脆就在dll的cpp文件第一行加上#define DLL_DLL2_EXPORTS.

`DLL`中的全局变量和对象

解决了重载函数的问题,则dll中的全局变量和对象都不是问题了,只是有一点语法注意.如源码所示:dll_object.h

#ifdef DLL_OBJECT_EXPORTS
#define DLL_OBJECT_API __declspec(dllexport)
#else
#define DLL_OBJECT_API __declspec(dllimport)
#endif
DLL_OBJECT_API void FuncInDll(void);
extern DLL_OBJECT_API int g_nDll;
class DLL_OBJECT_API CDll_Object {
public:CDll_Object(void);show(void);//`待办`:在此处添加你的方法.
};

Cpp文件dll_object.cpp如下:

#define DLL_OBJECT_EXPORTS
#include <objbase.h>
#include <iostream.h>
#include "dll_object.h"
DLL_OBJECT_API void FuncInDll(void)
{cout<<"FuncInDll is called!"<<endl;
}
DLL_OBJECT_API int g_nDll = 9;
CDll_Object::CDll_Object()
{cout<<"ctor of CDll_Object"<<endl;
}
CDll_Object::show()
{cout<<"function show in class CDll_Object"<<endl;
}
BOOL APIENTRY DllMain(HANDLE hModule, DWORD dwReason, void* lpReserved)
{HANDLE g_hModule;switch(dwReason){case DLL_PROCESS_ATTACH:g_hModule = (HINSTANCE)hModule;break;case DLL_PROCESS_DETACH:g_hModule=NULL;break;}return TRUE;
}

编译链接完后Dumpbin一下,可见输出了5个符号:

1    0 00001040   0CDll_Object@@QAE@XZ2    1 00001000   4CDll_Object@@QAEAAV0@ABV0@@Z3    2 00001020  FuncInDll@@YAXXZ4    3 00008040  g_nDll@@3HA5    4 00001069  show@CDll_Object@@QAEHXZ

它们分别代表CDll_Object类,类的构造器,FuncInDll函数,g_nDll全局变量和类的显示成员函数.下面是客户代码:dll_object_client.cpp

#include "dll_object.h"
#include <iostream.h>
//注意路径,加载`dll`的或`项目`|设置|`链接`设置里
#pragma comment(lib,"dll_object.lib")
int main(void)
{cout<<"call dll"<<endl;cout<<"call function in dll"<<endl;FuncInDll();//只要这样就可调用`dll`里的函数了cout<<"global var in dll g_nDll ="<<g_nDll<<endl;cout<<"call member function of class CDll_Object in dll"<<endl;CDll_Object obj;obj.show();return 0;
}

运行该客户可见:
calldll
callfunctionindll
FuncInDlliscalled!
globalvarindllg_nDll=9
callmemberfunctionofclassCDll_Objectindll
ctorofCDll_Object
functionshowinclassCDll_Object

可知,客户成功的访问了dll中的全局变量,并创建了dll中定义的C++对象,还调用了该对象的成员函数.