初学DLL，结合教程，总结一下自己的所得，希望对DLL初学者们有所帮助。
动态链接库（DLL）是从C语言函数库和Pascal库单元的概念发展而来的。所有的C语言标准库函数都存放在某一函数库中。在链接应用程序的过程中，链接器从库文件中拷贝程序调用的函数代码，并把这些函数代码添加到可执行文件中。这种方法同只把函数储存在已编译的OBJ文件中相比更有利于代码的重用。但随着Windows这样的多任务环境的出现，函数库的方法显得过于累赘。如果为了完成屏幕输出、消息处理、内存管理、对话框等操作，每个程序都不得不拥有自己的函数，那么Windows程序将变得非常庞大。Windows的发展要求允许同时运行的几个程序共享一组函数的单一拷贝。动态链接库就是在这种情况下出现的。动态链接库不用重复编译或链接，一旦装入内存，DLL函数可以被系统中的任何正在运行的应用程序软件所使用，而不必再将DLL函数的另一拷贝装入内存。
下面我们一步一步来建立一个DLL。
一、建立一个DLL工程
新建一个工程，选择Win32 控制台项目（Win32 Console Application），并且在应用程序设置标签（the advanced tab）上，选择DLL和空项目选项。
二、声明导出函数
这里有两种方法声明导出函数：一种是通过使用__declspec(dllexport)，添加到需要导出的函数前，进行声明；另外一种就是通过模块定义文件（Module-Definition File即.DEF）来进行声明。
第一种方法，建立头文件DLLSample.h，在头文件中，对需要导出的函数进行声明。
#ifndef _DLL_SAMPLE_H
#define _DLL_SAMPLE_H
// 如果定义了C++编译器，那么声明为C链接方式
#ifdef __cplusplus
extern "C" {
#endif
// 通过宏来控制是导入还是导出
#ifdef _DLL_SAMPLE
#define DLL_SAMPLE_API __declspec(dllexport)
#else
#define DLL_SAMPLE_API __declspec(dllimport)
#endif
// 导出/导入函数声明
DLL_SAMPLE_API void TestDLL(int);
#undef DLL_SAMPLE_API
#ifdef __cplusplus
}
#endif
#endif
这个头文件会分别被DLL和调用DLL的应用程序引入，当被DLL引入时，在DLL中定义_DLL_SAMPLE宏，这样就会在DLL模块中声明函数为导出函数；当被调用DLL的应用程序引入时，就没有定义_DLL_SAMPLE，这样就会声明头文件中的函数为从DLL中的导入函数。
第二种方法：模块定义文件是一个有着.def文件扩展名的文本文件。它被用于导出一个DLL的函数，和__declspec(dllexport)很相似，但是.def文件并不是Microsoft定义的。一个.def文件中只有两个必需的部分：LIBRARY 和 EXPORTS。
LIBRARY DLLSample
DESCRIPTION "my simple DLL"
EXPORTS
TestDLL @1 ；@1表示这是第一个导出函数
第一行，''LIBRARY''是一个必需的部分。它告诉链接器（linker）如何命名你的DLL。下面被标识为''DESCRIPTION''的部分并不是必需的。该语句将字符串写入 .rdata 节，它告诉人们谁可能使用这个DLL，这个DLL做什么或它为了什么（存在）。再下面的部分标识为''EXPORTS''是另一个必需的部分；这个部分使得该函数可以被其它应用程序访问到并且它创建一个导入库。当你生成这个项目时，不仅是一个.dll文件被创建，而且一个文件扩展名为.lib的导出库也被创建了。除了前面的部分以外，这里还有其它四个部分标识为：NAME, STACKSIZE,SECTIONS, 和 VERSION。另外，一个分号(;)开始一个注解，如同''//''在C++中一样。定义了这个文件之后，头文件中的__declspec(dllexport)就不需要声明了。
三、编写DllMain函数和导出函数
DllMain函数是DLL模块的默认入口点。当Windows加载DLL模块时调用这一函数。系统首先调用全局对象的构造函数，然后调用全局函数DLLMain。DLLMain函数不仅在将DLL链接加载到进程时被调用，在DLL模块与进程分离时（以及其它时候）也被调用。
#include "stdafx.h"
#define _DLL_SAMPLE
#ifndef _DLL_SAMPLE_H
#include "DLLSample.h"
#endif
#include "stdio.h"
//APIENTRY声明DLL函数入口点
BOOL APIENTRY DllMain(HANDLE 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;
}
void TestDLL(int arg)
{
printf("DLL output arg %d\n", arg);
}
如果程序员没有为DLL模块编写一个DLLMain函数，系统会从其它运行库中引入一个不做任何操作的缺省DLLMain函数版本。在单个线程启动和终止时，DLLMain函数也被调用。
然后，F7编译，就得到一个DLL了
c++中DLL导出类(2)
2、导出变量、常量、对象
很多时候不需要导出一个类，可以让DLL导出一个变量、常量、对象，导出它们只需要进行简单的声明：_declspec(dllexport)int MyInt;
_declspec(dllexport) extern const COLORREF MyColor=RGB(0,0,0);
_declspec(dllexport) CRect rect(10,10,20,20);
要导出一个常量时必须使用关键字extern，否则会发生连接错误。
注意：如果客户程序识别这个类而且有自己的头文件，则只能导出一个类对象。如果在DLL中创建一个类，客户程序不使用头文件就无法识别这个类。
当导出一个对象或者变量时，载入DLL的每个客户程序都有一个自己的拷贝。也就是如果两个程序使用的是同一个DLL，一个应用程序所做的修改不会影响另一个应用程序。
我们在导出的时候只能导出DLL中的全局变量或对象，而不能导出局部的变量和对象，因为它们过了作用域也就不存在了，那样DLL就不能正常工作。如：
MyFunction()
{
_declspec(dllexport) int MyInt;
_declspec(dllexport) CMyClass object;
}
3、导出函数
导出函数和导出变量/对象类似，只要把_declspec(dllexport)加到函数原型开始的位置：
_declspec(dllexport) int MyFunction(int);
如果是常规DLL，它将和C写的程序使用，声明方式如下：
extern "c" _declspec(dllexport) int MyFunction(int);
实现：
extern "c" _declspec(dllexport) int MyFunction(int x)
{
...//操作
}
如果创建的是动态连接到MFC代码库DLL的常规DLL，则必须插入AFX_MANAGE_STATE作为导出函数的首行，因此定义如下：
extern "c" _declspec(dllexport) int MyFunction(int x)
{
AFX_MANAGE_STATE(AfxGetStaticModuleState());
...//操作
}
有时候为了安全起见，在每个常规DLL里都加上，也不会有任何问题，只是在静态连接的时候这个宏无效而已。这是导出函数的方法，记住只有MFC扩展DLL才能让参数和返回值使用MFC的数据类型。
4、导出指针
导出指针的方式如下：
_declspec(dllexport) int *pint;
_declspec(dllexport) CMyClass object = new CMyClass;
如果声明的时候同时初始化了指针，就需要找到合适的地方类释放指针。在扩展DLL中有个函数DllMain()。（注意函数名中的两个l要是小写字母），可以在这个函数中处理指针：
# include "MyClass.h"
_declspec(dllexport) CMyClass *pobject = new CMyClass;
DllMain(HINSTANCE hInstance,DWORD dwReason,LPVOID lpReserved)
{
if(dwReason == DLL_PROCESS_ATTACH)
{
.....//
}
else if(dwReason == DLL_PROCESS_DETACH)
{
delete pobject;
}
}
常规DLL有一个从CWinApp派生的类对象处理DLL的开和关，可以使用类向导添加InitInstance/ExitInstance函数。
int CMyDllApp::ExitInstance()
{
delete pobject;
return CWinApp::ExitInstance();
}
前面介绍了怎么从DLL中导出函数，下面我们来看一下如何从DLL中导出变量来。
声明为导出变量时，同样有两种方法：
第一种是用__declspec进行导出声明
#ifndef _DLL_SAMPLE_H
#define _DLL_SAMPLE_H
// 如果定义了C++编译器，那么声明为C链接方式
#ifdef __cplusplus
extern "C" {
#endif
// 通过宏来控制是导入还是导出
#ifdef _DLL_SAMPLE
#define DLL_SAMPLE_API __declspec(dllexport)
#else
#define DLL_SAMPLE_API __declspec(dllimport)
#endif
// 导出/导入变量声明
DLL_SAMPLE_API extern int DLLData;
#undef DLL_SAMPLE_API
#ifdef __cplusplus
}
#endif
#endif
第二种是用模块定义文件（.def）进行导出声明
LIBRARY DLLSample
DESCRIPTION "my simple DLL"
EXPORTS
DLLData DATA ；DATA表示这是数据（变量）
下面是DLL的实现文件
#include "stdafx.h"
#define _DLL_SAMPLE
#ifndef _DLL_SAMPLE_H
#include "DLLSample.h"
#endif
#include "stdio.h"
int DLLData;
//APIENTRY声明DLL函数入口点
BOOL APIENTRY DllMain(HANDLE hModule, DWORD ul_reason_for_call, LPVOID lpReserved)
{
switch (ul_reason_for_call)
{
case DLL_PROCESS_ATTACH:
DLLData = 123; // 在入口函数中对变量进行初始化
break
case DLL_THREAD_ATTACH:
case DLL_THREAD_DETACH:
case DLL_PROCESS_DETACH:
break;
}
return TRUE;
}
同样，应用程序调用DLL中的变量也有两种方法。
第一种是隐式链接：
#include <stdio.h>
#include "DLLSample.h"
#pragma comment(lib,"DLLSample.lib")
int main(int argc, char *argv[])
{
printf("%d ", DLLSample);
return 0;
}
第二种是显式链接：
#include <iostream>
#include <windows.h>
int main()
{
int my_int;
HINSTANCE hInstLibrary = LoadLibrary("DLLSample.dll");
if (hInstLibrary == NULL)
{
FreeLibrary(hInstLibrary);
}
my_int = *(int*)GetProcAddress(hInstLibrary, "DLLData");
if (dllFunc == NULL)
{
FreeLibrary(hInstLibrary);
}
std::cout<<my_int;
std::cin.get();
FreeLibrary(hInstLibrary);
return(1);
}
通过GetProcAddress取出的函数或者变量都是地址，因此，需要解引用并且转类型。
前面介绍了怎么从DLL中导出函数和变量，实际上导出类的方法也是大同小异，废话就不多说了，下面给个简单例子示范一下，也就不多做解释了。
DLL头文件：
#ifndef _DLL_SAMPLE_H
#define _DLL_SAMPLE_H
// 通过宏来控制是导入还是导出
#ifdef _DLL_SAMPLE
#define DLL_SAMPLE_API __declspec(dllexport)
#else
#define DLL_SAMPLE_API __declspec(dllimport)
#endif
// 导出/导入变量声明
DLL_SAMPLE_API class DLLClass
{
public:
void Show();
};
#undef DLL_SAMPLE_API
#endif
DLL实现文件：
#include "stdafx.h"
#define _DLL_SAMPLE
#ifndef _DLL_SAMPLE_H
#include "DLLSample.h"
#endif
#include "stdio.h"
//APIENTRY声明DLL函数入口点
BOOL APIENTRY DllMain(HANDLE 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;
}
void DLLClass::Show()
{
printf("DLLClass show!");
}
应用程序调用DLL
#include "DLLSample.h"
#pragma comment(lib,"DLLSample.lib")
int main(int argc, char *argv[])
{
DLLClass dc;
dc.Show();
return 0;
}
大家可能发现了，上面我没有使用模块定义文件（.def）声明导出类也没有用显式链接导入DLL。
用Depends查看前面编译出来的DLL文件，会发现里面导出了很奇怪的symbol，这是因为C++编译器在编译时会对symbol进行修饰。
这是我从别人那儿转来的截图。
网上找了下，发现了C++编译时函数名的修饰约定规则
__stdcall调用约定：
1、以"?"标识函数名的开始，后跟函数名；
2、函数名后面以"@@YG"标识参数表的开始，后跟参数表；
3、参数表以代号表示：
X——void，
D——char，
E——unsigned char，
F——short，
H——int，
I——unsigned int，
J——long，
K——unsigned long，
M——float，
N——double，
_N——bool，
....
PA——表示指针，后面的代号表明指针类型，如果相同类型的指针连续出现，以"0"代替，一个"0"代表一次重复；
4、参数表的第一项为该函数的返回值类型，其后依次为参数的数据类型,指针标识在其所指数据类型前；
5、参数表后以"@Z"标识整个名字的结束，如果该函数无参数，则以"Z"标识结束。
其格式为"?functionname@@YG*****@Z"或?functionname@@YG*XZ，
int Test1（char *var1,unsigned long）-----“?Test1@@YGHPADK@Z”
void Test2（） -----“?Test2@@YGXXZ”
__cdecl调用约定：
规则同上面的_stdcall调用约定，只是参数表的开始标识由上面的"@@YG"变为"@@YA"。
__fastcall调用约定：
规则同上面的_stdcall调用约定，只是参数表的开始标识由上面的"@@YG"变为"@@YI"。
VC++对函数的省缺声明是"__cedcl",将只能被C/C++调用。
虽然因为C++编译器对symbol进行修饰的原因不能直接用def文件声明导出类和显式链接，但是可以用另外一种取巧的方式。
在头文件中类的声明中添加一个友元函数：
friend DLLClass* CreatDLLClass();
然后声明CreatDLLClass()为导出函数，通过调用该函数返回一个DLLClass类的对象，同样达到了导出类的目的。
这样，就可以用显式链接来调用CreatDLLClass()，从而得到类对象了。
在Win16环境中，DLL的全局数据对每个载入它的进程来说都是相同的,因为所有的进程用的都收同一块地址空间；而在Win32环境中，情况却发生了变化，每个进程都有了它自己的地址空间，DLL函数中的代码所创建的任何对象（包括变量）都归调用它的进程所有。当进程在载入DLL时，操作系统自动把DLL地址映射到该进程的私有空间，也就是进程的虚拟地址空间，而且也复制该DLL的全局数据的一份拷贝到该进程空间。（在物理内存中，多进程载入DLL时，DLL的代码段实际上是只加载了一次，只是将物理地址映射到了各个调用它的进程的虚拟地址空间中，而全局数据会在每个进程都分别加载）。也就是说每个进程所拥有的相同的DLL的全局数据，它们的名称相同，但其值却并不一定是相同的，而且是互不干涉的。
因此，在Win32环境下要想在多个进程中共享数据，就必须进行必要的设置。在访问同一个Dll的各进程之间共享存储器是通过存储器映射文件技术实现的。也可以把这些需要共享的数据分离出来，放置在一个独立的数据段里，并把该段的属性设置为共享。必须给这些变量赋初值，否则编译器会把没有赋初始值的变量放在一个叫未被初始化的数据段中。
在DLL的实现文件中添加下列代码：
#pragma data_seg("DLLSharedSection") // 声明共享数据段，并命名该数据段
int SharedData = 123; // 必须在定义的同时进行初始化!!!!
#pragma data_seg()
在#pragma data_seg("DLLSharedSection")和#pragma data_seg()之间的所有变量将被访问该Dll的所有进程看到和共享。仅定义一个数据段还不能达到共享数据的目的，还要告诉编译器该段的属性，有三种方法可以实现该目的（其效果是相同的），一种方法是在.DEF文件中加入如下语句：
SETCTIONS
DLLSharedSection READ WRITE SHARED
另一种方法是在项目设置的链接选项(Project Setting --〉Link)中加入如下语句：
/SECTION:DLLSharedSection,rws
还有一种就是使用指令：
#pragma comment(linker,"/section:.DLLSharedSection,rws")
那么这个数据节中的数据可以在所有DLL的实例之间共享了。所有对这些数据的操作都针对同一个实例的，而不是在每个进程的地址空间中都有一份。
当进程隐式或显式调用一个动态库里的函数时，系统都要把这个动态库映射到这个进程的虚拟地址空间里。这使得DLL成为进程的一部分，以这个进程的身份执行，使用这个进程的堆栈。
下面来谈一下在具体使用共享数据段时需要注意的一些问题：
· 所有在共享数据段中的变量，只有在数据段中经过了初始化之后，才会是进程间共享的。如果没有初始化，那么进程间访问该变量则是未定义的。
· 所有的共享变量都要放置在共享数据段中。如何定义很大的数组，那么也会导致很大的DLL。
· 不要在共享数据段中存放进程相关的信息。Win32中大多数的数据结构和值（比如HANDLE）只在特定的进程上下文中才是有效地。
· 每个进程都有它自己的地址空间。因此不要在共享数据段中共享指针，指针指向的地址在不同的地址空间中是不一样的。
· DLL在每个进程中是被映射在不同的虚拟地址空间中的，因此函数指针也是不安全的。
当然还有其它的方法来进行进程间的数据共享，比如文件内存映射等，这就涉及到通用的进程间通信了，这里就不多讲了。
c#不支持这种dll它自己使用的是类库
扫一扫
7万+
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
