数学建模社区-数学中国

标题: DLL(Dynamic Link Libraries)专题(转帖) 选择自 laiyiling 的 Blog [打印本页]
作者: xShandow    时间: 2004-9-9 11:09
标题: DLL(Dynamic Link Libraries)专题(转帖) 选择自 laiyiling 的 Blog
<><a href="http://www.microsoft.com/china/community/program/OriginalArticles/techdoc/dll.mspx" target="_blank" >http://www.microsoft.com/china/community/program/OriginalArticles/techdoc/dll.mspx</A></P>) r8 q" q& L, Y
<DIV class=text4></DIV>
- w  c$ I* {2 Z8 G9 r, C<UL>
  i/ k0 j9 `3 P# q<LI class=list2><B></B>引言 , F5 q/ g5 q$ X* m1 h
<LI class=list2><B></B>调用方式
9 b2 {$ y3 r6 L6 \# n<LI class=list2><B></B>MFC中的DLL
9 X; G4 ?$ x, f& V0 Z<LI class=list2><B></B>DLL入口函数
; t3 ^6 J) ]% n( t9 e, m& F<LI class=list2><B></B>关于约定
/ n8 ~$ ]# v. O' a. A<LI class=list2><B></B>关于DLL的函数 8 _6 W4 M1 d' f6 e5 `# t4 G
<LI class=list2><B></B>模块定义文件(.DEF)
6 J! o+ C% v7 S$ |" j7 [<LI class=list2><B></B>DLL程序和调用其输出函数的程序的关系
2 Q3 U6 K) w% {/ [( U" o$ P<LI class=list2><B></B>作者</LI></UL>
- u' |$ D. x& _6 Q$ y- ^<HR color=#cccccc SIZE=1>
: R; u& Y5 i! Q$ }% {1 A0 d- ~/ H/ f. u
<DIV class=text2>引言</DIV>
8 F  r" V% O" g9 V# }& d2 ~6 Q<DIV class=text4></DIV>: q% Z7 p" T- ?$ k4 u5 c
<DIV class=text4>比较大的应用程序都由很多模块组成，这些模块分别完成相对独立的功能，它们彼此协作来完成整个软件系统的工作。可能存在一些模块的功能较为通用，在构造其它软件系统时仍会被使用。在构造软件系统时，如果将所有模块的源代码都静态编译到整个应用程序EXE文件中，会产生一些问题：一个缺点是增加了应用程序的大小，它会占用更多的磁盘空间，程序运行时也会消耗较大的内存空间，造成系统资源的浪费；另一个缺点是，在编写大的EXE程序时，在每次修改重建时都必须调整编译所有源代码，增加了编译过程的复杂性，也不利于阶段性的单元测试。 </DIV>
' z3 ]! S6 B  h; h<DIV class=text4>Windows系统平台上提供了一种完全不同的较有效的编程和运行环境，你可以将独立的程序模块创建为较小的DLL(Dynamic Linkable Library)文件，并可对它们单独编译和测试。在运行时，只有当EXE程序确实要调用这些DLL模块的情况下，系统才会将它们装载到内存空间中。这种方式不仅减少了EXE文件的大小和对内存空间的需求，而且使这些DLL模块可以同时被多个应用程序使用。Windows自己就将一些主要的系统功能以DLL模块的形式实现。 </DIV>0 G8 s# `* s% U2 m! n. e/ Z8 t9 e
<DIV class=text4>一般来说，DLL是一种磁盘文件，以.dll、.DRV、.FON、.SYS和许多以.EXE为扩展名的系统文件都可以是DLL。它由全局数据、服务函数和资源组成，在运行时被系统加载到进程的虚拟空间中，成为调用进程的一部分。如果与其它DLL之间没有冲突，该文件通常映射到进程虚拟空间的同一地址上。DLL模块中包含各种导出函数，用于向外界提供服务。DLL可以有自己的数据段，但没有自己的堆栈，使用与调用它的应用程序相同的堆栈模式；一个DLL在内存中只有一个实例；DLL实现了代码封装性；DLL的编制与具体的编程语言及编译器无关。 </DIV>& U7 ]0 `) \6 l" I2 x- D/ t2 f, u
<DIV class=text4>在Win32环境中，每个进程都复制了自己的读/写全局变量。如果想要与其它进程共享内存，必须使用内存映射文件或者声明一个共享数据段。DLL模块需要的堆栈内存都是从运行进程的堆栈中分配出来的。Windows在加载DLL模块时将进程函数调用与DLL文件的导出函数相匹配。Windows操作系统对DLL的操作仅仅是把DLL映射到需要它的进程的虚拟地址空间里去。DLL函数中的代码所创建的任何对象（包括变量）都归调用它的线程或进程所有. </DIV>7 A8 r% D1 `7 n2 o* C! P4 z
<HR color=#cccccc SIZE=1>  ]0 P5 ?6 [7 ?* Q- D0 ^
( [: W6 O! T0 [' X# G# ]1 b
<DIV class=text2>调用方式</DIV>) j0 F0 f* Y6 Q5 W, B
<DIV class=text4></DIV>8 O" x! N- J- @1 A( q  r
<DIV class=text4>1、静态调用方式：由编译系统完成对DLL的加载和应用程序结束时DLL卸载的编码（如还有其它程序使用该DLL，则Windows对DLL的应用记录减1，直到所有相关程序都结束对该DLL的使用时才释放它），简单实用，但不够灵活，只能满足一般要求。</DIV>
* }  S; @# S7 y<DIV class=text4>隐式的调用：需要把产生动态连接库时产生的.LIB文件加入到应用程序的工程中，想使用DLL中的函数时，只须说明一下。隐式调用不需要调用LoadLibrary()和FreeLibrary()。程序员在建立一个DLL文件时，链接程序会自动生成一个与之对应的LIB导入文件。该文件包含了每一个DLL导出函数的符号名和可选的标识号，但是并不含有实际的代码。LIB文件作为DLL的替代文件被编译到应用程序项目中。</DIV>
) M0 M3 x6 J0 q* P0 g<DIV class=text4>当程序员通过静态链接方式编译生成应用程序时，应用程序中的调用函数与LIB文件中导出符号相匹配，这些符号或标识号进入到生成的EXE文件中。LIB文件中也包含了对应的DLL文件名（但不是完全的路径名），链接程序将其存储在EXE文件内部。</DIV>
# z( [) `4 n) L- F4 ~6 I& i3 q% ~<DIV class=text4>当应用程序运行过程中需要加载DLL文件时，Windows根据这些信息发现并加载DLL，然后通过符号名或标识号实现对DLL函数的动态链接。所有被应用程序调用的DLL文件都会在应用程序EXE文件加载时被加载在到内存中。可执行程序链接到一个包含DLL输出函数信息的输入库文件(.LIB文件)。操作系统在加载使用可执行程序时加载DLL。可执行程序直接通过函数名调用DLL的输出函数，调用方法和程序内部其他的函数是一样的。</DIV>
$ B& C9 H! h6 u+ t) R& p0 e<DIV class=text4>2、动态调用方式：是由编程者用API函数加载和卸载DLL来达到调用DLL的目的，使用上较复杂，但能更加有效地使用内存，是编制大型应用程序时的重要方式。</DIV>+ G8 i* Y! R% V% ]
<DIV class=text4>显式的调用：是指在应用程序中用LoadLibrary或MFC提供的AfxLoadLibrary显式的将自己所做的动态连接库调进来，动态连接库的文件名即是上面两个函数的参数，再用GetProcAddress()获取想要引入的函数。自此，你就可以象使用如同本应用程序自定义的函数一样来调用此引入函数了。在应用程序退出之前，应该用FreeLibrary或MFC提供的AfxFreeLibrary释放动态连接库。直接调用Win32 的LoadLibary函数，并指定DLL的路径作为参数。LoadLibary返回HINSTANCE参数，应用程序在调用GetProcAddress函数时使用这一参数。GetProcAddress函数将符号名或标识号转换为DLL内部的地址。程序员可以决定DLL文件何时加载或不加载，显式链接在运行时决定加载哪个DLL文件。使用DLL的程序在使用之前必须加载（LoadLibrary）加载DLL从而得到一个DLL模块的句柄，然后调用GetProcAddress函数得到输出函数的指针，在退出之前必须卸载DLL(FreeLibrary)。</DIV>
+ q0 O. d0 R( t<DIV class=text4>Windows将遵循下面的搜索顺序来定位DLL： </DIV>% }' M6 j3 h2 x" m& _# j) C
<DIV class=text4>1．包含EXE文件的目录</DIV>
6 G6 @" C/ z! B2 \4 B( W7 T<DIV class=text4>2．进程的当前工作目录 </DIV>, r) i4 N- V+ Y' ^# k5 d6 |
<DIV class=text4>3．Windows系统目录 </DIV>9 g' N7 t0 C. v2 |# i
<DIV class=text4>4．Windows目录 </DIV>. t& e. f8 p. q& M9 L/ s
<DIV class=text4>5．列在Path环境变量中的一系列目录</DIV>. q) v1 s6 w& s2 G! A
<HR color=#cccccc SIZE=1>
# A9 T$ H* I: J  W; N1 A; @- ^6 s9 P7 D
<DIV class=text2>MFC中的DLL</DIV>9 i* B; P1 g" P8 z: _
<DIV class=text4></DIV>, Z+ S- c2 W1 X
<DIV class=text4>a、Non-MFC DLL:指的是不用MFC的类库结构，直接用C语言写的DLL，其输出的函数一般用的是标准C接口，并能被非MFC或MFC编写的应用程序所调用。</DIV>7 S) w% h) W) G% r- \' D* x5 D
<DIV class=text4>b、Regular DLL:和下述的Extension DLLs一样，是用MFC类库编写的。明显的特点是在源文件里有一个继承CWinApp的类。其又可细分成静态连接到MFC和动态连接到MFC上的。</DIV>: R& d/ c; `& L4 C# [
<DIV class=text4>静态连接到MFC的动态连接库只被VC的专业般和企业版所支持。该类DLL应用程序里头的输出函数可以被任意Win32程序使用，包括使用MFC的应用程序。输入函数有如下形式：</DIV>
- R8 o6 M6 E$ h5 ~( a9 i<DIV class=text4>extern "C" EXPORT YourExportedFunction( );</DIV>6 c3 x- H) j, r! @2 V5 ^( p: h
<DIV class=text4>如果没有extern "C"修饰，输出函数仅仅能从C++代码中调用。</DIV>. t* H& R$ {% m. H3 C: f
<DIV class=text4>DLL应用程序从CWinApp派生，但没有消息循环。</DIV>1 [: F: k5 M& B! a
<DIV class=text4>动态链接到MFC的规则DLL应用程序里头的输出函数可以被任意Win32程序使用，包括使用MFC的应用程序。但是，所有从DLL输出的函数应该以如下语句开始：</DIV>% Y. y1 J& q. K- d
<DIV  width="100%"><RE>AFX_MANAGE_STATE(AfxGetStaticModuleState( ))
& F$ J9 A; ]: @3 v) z+ T- g! v* p8 P</PRE></DIV>& w- u1 G8 ]) k" F4 F
<DIV class=text4>此语句用来正确地切换MFC模块状态。</DIV>6 X+ z5 x& D8 e  b) z
<DIV class=text4>Regular DLL能够被所有支持DLL技术的语言所编写的应用程序所调用。在这种动态连接库中，它必须有一个从CWinApp继承下来的类，DLLMain函数被MFC所提供，不用自己显式的写出来。</DIV>( @; o" k+ `  `# ~" g* A2 `
<DIV class=text4>c、Extension DLL:用来实现从MFC所继承下来的类的重新利用，也就是说，用这种类型的动态连接库，可以用来输出一个从MFC所继承下来的类。它输出的函数仅可以被使用MFC且动态链接到MFC的应用程序使用。可以从MFC继承你所想要的、更适于你自己用的类，并把它提供给你的应用程序。你也可随意的给你的应用程序提供MFC或MFC继承类的对象指针。Extension DLL使用MFC的动态连接版本所创建的，并且它只被用MFC类库所编写的应用程序所调用。Extension DLLs 和Regular DLLs不一样，它没有一个从CWinApp继承而来的类的对象，所以，你必须为自己DLLMain函数添加初始化代码和结束代码。</DIV>
  }$ b2 F, B6 }" W<DIV class=text4>和规则DLL相比，有以下不同：</DIV>+ y; |' H' M# d# y/ T2 K& _
<DIV class=text4>1、它没有一个从CWinApp派生的对象；</DIV>
" P4 _6 P9 k2 W$ [- v) K8 Z/ r; j<DIV class=text4>2、它必须有一个DLLMain函数；</DIV>) R" w$ W  `! y  B9 l
<DIV class=text4>3、DLLMain调用AfxInitExtensionModule函数，必须检查该函数的返回值，如果返回0，DLLMmain也返回0；</DIV>1 j; y+ _, b/ b9 w2 K+ }
<DIV class=text4>4、如果它希望输出CRuntimeClass类型的对象或者资源(Resources)，则需要提供一个初始化函数来创建一个CDynLinkLibrary对象。并且，有必要把初始化函数输出；</DIV>3 N) Z  Q' ]) v% R# i
<DIV class=text4>5、使用扩展DLL的MFC应用程序必须有一个从CWinApp派生的类，而且，一般在InitInstance里调用扩展DLL的初始化函数。</DIV>
4 }) F" k  ]4 c& I<HR color=#cccccc SIZE=1>6 r. o) O4 X& z0 Z8 l
1 D2 h4 @2 T: I& N5 f2 U
<DIV class=text2>DLL入口函数</DIV>
6 t( k& n2 |6 N8 M<DIV class=text4></DIV>
/ d) s: c: J( N<DIV class=text4>1、每一个DLL必须有一个入口点，DLLMain是一个缺省的入口函数。DLLMain负责初始化(Initialization)和结束(Termination)工作，每当一个新的进程或者该进程的新的线程访问DLL时，或者访问DLL的每一个进程或者线程不再使用DLL或者结束时，都会调用DLLMain。但是，使用TerminateProcess或TerminateThread结束进程或者线程，不会调用DLLMain。</DIV>
+ c: Z# N  j, k, Z7 Z/ T% _% n. N<DIV class=text4>DLLMain的函数原型：</DIV># `) ~! g7 P+ f) U. |9 u
<DIV  width="100%"><RE>BOOL APIENTRY DLLMain(HANDLE hModule,DWORD ul_reason_for_call,LPVOID 6 A' r  ^# ~" p
lpReserved)
* j' J3 E9 \, q) j( I{% a/ r9 X" v, u7 ]$ R  x5 K7 j6 y
        switch(ul_reason_for_call) 5 W  o8 @1 N/ I6 V$ P
        {% L5 ]; G, P& J7 u" t! w; \+ O
        case DLL_PROCESS_ATTACH:) |; [. r+ U# x
        .......$ r' B3 p3 B' i3 z6 q. k$ B
        case DLL_THREAD_ATTACH:( a4 a6 ^. E) M4 c# k
        .......% o4 V- r9 o) w8 ^  h/ L( F
        case DLL_THREAD_DETACH:9 q4 j1 j8 V7 V' I! y$ S) |
        .......9 W7 f) b/ E9 j% m
        case DLL_PROCESS_DETACH:% o$ a0 C8 R5 L7 q. Z' k, ]: O
        .......
$ Q, |" b+ {& r6 t' V% U        return TRUE;: X% u' I9 x5 W
        }
- n, C; k) p. \/ r) _}
) B* K4 m% i+ P7 M9 I7 }</PRE></DIV>
% ^" ]4 S' B' G2 J+ l% ^<DIV class=text4>参数：</DIV>
! B+ r1 I, Y/ X5 V, p<DIV class=text4>hMoudle：是动态库被调用时所传递来的一个指向自己的句柄(实际上，它是指向_DGROUP段的一个选择符)；</DIV>1 l  Y' `2 y3 C! H, B3 W
<DIV class=text4>ul_reason_for_call：是一个说明动态库被调原因的标志。当进程或线程装入或卸载动态连接库的时候，操作系统调用入口函数，并说明动态连接库被调用的原因。它所有的可能值为：</DIV>
, t- A2 T1 w- i' P. W% h<DIV class=text4>DLL_PROCESS_ATTACH: 进程被调用；</DIV>4 [1 h9 v/ V% _
<DIV class=text4>DLL_THREAD_ATTACH: 线程被调用；</DIV>' p( Q* Y, Q  ?# ]- Q) K
<DIV class=text4>DLL_PROCESS_DETACH: 进程被停止；</DIV>
4 ^* i# C0 H/ l<DIV class=text4>DLL_THREAD_DETACH: 线程被停止；</DIV>
" @, b' t+ S, f8 G<DIV class=text4>lpReserved：是一个被系统所保留的参数。</DIV>
% C! A$ H4 h6 N; \% q  ^5 N<DIV class=text4>2、_DLLMainCRTStartup</DIV>+ o7 V4 B% ]. g$ ?
<DIV class=text4>为了使用"C"运行库(CRT，C Run time Library)的DLL版本（多线程），一个DLL应用程序必须指定_DLLMainCRTStartup为入口函数，DLL的初始化函数必须是DLLMain。</DIV>7 D) C) \2 O  ~% @8 w9 \
<DIV class=text4>_DLLMainCRTStartup完成以下任务：当进程或线程捆绑(Attach)到DLL时为"C"运行时的数据(C Runtime Data)分配空间和初始化并且构造全局"C++"对象，当进程或者线程终止使用DLL(Detach)时，清理C Runtime Data并且销毁全局"C++"对象。它还调</DIV>9 k( j; l( ^& `5 s
<DIV class=text4>用DLLMain和RawDLLMain函数。</DIV>
: o9 x- j& [3 m( V<DIV class=text4>RawDLLMain在DLL应用程序动态链接到MFC DLL时被需要，但它是静态的链接到DLL应用程序的。在讲述状态管理时解释其原因。</DIV>
; x. l0 z1 ^  t# x+ i1 v5 f<HR color=#cccccc SIZE=1>! v% c. Y; ]1 H- |% d

* y: }2 i; r. K( k<DIV class=text2>关于约定</DIV>. x; R% u& A4 q2 H! M
<DIV class=text4></DIV>' R$ E6 b' m8 B/ w5 A4 K0 t8 t
<DIV class=text4>动态库输出函数的约定有两种：调用约定和名字修饰约定。</DIV>
# M8 B9 i) h2 k" e6 |4 ~) ^<DIV class=text4>1)调用约定(Calling convention)：决定函数参数传送时入栈和出栈的顺序，由调用者还是被调用者把参数弹出栈，以及编译器用来识别函数名字的修饰约定。</DIV>) Z1 f' k, x# c, K0 t
<DIV class=text4>函数调用约定有多种，这里简单说一下：</DIV>" Z, h6 g$ T) Z5 J9 P, h8 B* W
<DIV class=text4>1、__stdcall调用约定相当于16位动态库中经常使用的PASCAL调用约定。在32位的VC++5.0中PASCAL调用约定不再被支持（实际上它已被定义为__stdcall。除了__pascal外，__fortran和__syscall也不被支持），取而代之的是__stdcall调用约定。两者实质上是一致的，即函数的参数自右向左通过栈传递，被调用的函数在返回前清理传送参数的内存栈，但不同的是函数名的修饰部分（关于函数名的修饰部分在后面将详细说明）。</DIV>) W/ X+ z+ C1 ?' }
<DIV class=text4>_stdcall是Pascal程序的缺省调用方式，通常用于Win32 Api中，函数采用从右到左的压栈方式，自己在退出时清空堆栈。VC将函数编译后会在函数名前面加上下划线前缀，在函数名后加上"@"和参数的字节数。</DIV>' m5 `! j$ q8 O7 f" y8 u1 q
<DIV class=text4>2、C调用约定（即用__cdecl关键字说明）按从右至左的顺序压参数入栈，由调用者把参数弹出栈。对于传送参数的内存栈是由调用者来维护的（正因为如此，实现可变参数的函数只能使用该调用约定）。另外，在函数名修饰约定方面也有所不同。</DIV>
& p& D, k4 e7 k, P<DIV class=text4>_cdecl是C和C＋＋程序的缺省调用方式。每一个调用它的函数都包含清空堆栈的代码，所以产生的可执行文件大小会比调用_stdcall函数的大。函数采用从右到左的压栈方式。VC将函数编译后会在函数名前面加上下划线前缀。是MFC缺省调用约定。</DIV>
; Z& X- u& ?( y! G<DIV class=text4>3、__fastcall调用约定是"人"如其名，它的主要特点就是快，因为它是通过寄存器来传送参数的（实际上，它用ECX和EDX传送前两个双字（DWORD）或更小的参数，剩下的参数仍旧自右向左压栈传送，被调用的函数在返回前清理传送参数的内存栈），在函数名修饰约定方面，它和前两者均不同。</DIV>+ [4 E8 {1 q( H
<DIV class=text4>_fastcall方式的函数采用寄存器传递参数，VC将函数编译后会在函数名前面加上"@"前缀，在函数名后加上"@"和参数的字节数。 </DIV>  {& O$ o) G, E& s2 |
<DIV class=text4>4、thiscall仅仅应用于"C++"成员函数。this指针存放于CX寄存器，参数从右到左压。thiscall不是关键词，因此不能被程序员指定。</DIV>
6 u  O# Z; [# e: D<DIV class=text4>5、naked call采用1-4的调用约定时，如果必要的话，进入函数时编译器会产生代码来保存ESI，EDI，EBX，EBP寄存器，退出函数时则产生代码恢复这些寄存器的内容。</DIV>: m% e, J7 o& G" R, i9 s/ t
<DIV class=text4>naked call不产生这样的代码。naked call不是类型修饰符，故必须和_declspec共同使用。</DIV>
! i# L6 m& \5 p, J! x. a; H<DIV class=text4>关键字 __stdcall、__cdecl和__fastcall可以直接加在要输出的函数前，也可以在编译环境的Setting...\C/C++ \Code Generation项选择。当加在输出函数前的关键字与编译环境中的选择不同时，直接加在输出函数前的关键字有效。它们对应的命令行参数分别为/Gz、/Gd和/Gr。缺省状态为/Gd，即__cdecl。</DIV>
3 G  o& C" z# w! R  J6 T<DIV class=text4>要完全模仿PASCAL调用约定首先必须使用__stdcall调用约定，至于函数名修饰约定，可以通过其它方法模仿。还有一个值得一提的是WINAPI宏，Windows.h支持该宏，它可以将出函数翻译成适当的调用约定，在WIN32中，它被定义为__stdcall。使用WINAPI宏可以创建自己的APIs。</DIV>1 w2 ]  X; n& o5 m/ F
<DIV class=text4>2)名字修饰约定</DIV>2 `9 s: \7 Y) E0 J1 d/ r
<DIV class=text4>1、修饰名(Decoration name)</DIV>8 G9 W9 r! \; C9 y
<DIV class=text4>"C"或者"C++"函数在内部（编译和链接）通过修饰名识别。修饰名是编译器在编译函数定义或者原型时生成的字符串。有些情况下使用函数的修饰名是必要的，如在模块定义文件里头指定输出"C++"重载函数、构造函数、析构函数，又如在汇编代码里调</DIV>
3 _( j+ f% H; S2 \% {, |<DIV class=text4>用"C""或"C++"函数等。</DIV>% H- z; n) Z* {. L9 d- C( ^
<DIV class=text4>修饰名由函数名、类名、调用约定、返回类型、参数等共同决定。</DIV>% S& R1 z' N# y. R6 H# q
<DIV class=text4>2、名字修饰约定随调用约定和编译种类(C或C++)的不同而变化。函数名修饰约定随编译种类和调用约定的不同而不同，下面分别说明。</DIV>6 p9 w% S+ d) s1 c6 t3 p0 w
<DIV class=text4>a、C编译时函数名修饰约定规则：</DIV>
" k9 W, [$ x. [: ~7 n& p# `<DIV class=text4>__stdcall调用约定在输出函数名前加上一个下划线前缀，后面加上一个"@"符号和其参数的字节数，格式为_functionname@number。</DIV>
9 U2 K/ [$ e" q" {6 }( u<DIV class=text4>__cdecl调用约定仅在输出函数名前加上一个下划线前缀，格式为_functionname。</DIV>
0 k3 @3 d8 v& J$ M* S/ W<DIV class=text4></DIV>& N" k6 E+ H' A5 j( \* h% V
<DIV class=text4>__fastcall调用约定在输出函数名前加上一个"@"符号，后面也是一个"@"符号和其参数的字节数，格式为@functionname@number。</DIV>+ e* n9 b4 P6 P0 a" f' o$ y
<DIV class=text4>它们均不改变输出函数名中的字符大小写，这和PASCAL调用约定不同，PASCAL约定输出的函数名无任何修饰且全部大写。</DIV>
( X7 `( k# n9 o" J  D: P: i2 d" r<DIV class=text4>b、C++编译时函数名修饰约定规则：</DIV>- ~& [& r2 x. g5 Z  R
<DIV class=text4>__stdcall调用约定：</DIV>( X7 s$ I3 \( Q. j0 g# O
<DIV class=text4>1、以"?"标识函数名的开始，后跟函数名；</DIV>
* K* v, A. J" U. _( v<DIV class=text4>2、函数名后面以"@@YG"标识参数表的开始，后跟参数表；</DIV>
* A0 p- y; I1 p+ O+ p<DIV class=text4>3、参数表以代号表示：</DIV>
* R1 u/ I# j, z: N<DIV class=text4>X--void ，</DIV>: d4 U# K/ C* ~2 F; V
<DIV class=text4>D--char，</DIV>
( o( Y" t3 u* Z4 S, ?1 o<DIV class=text4>E--unsigned char，</DIV>7 s/ a9 M+ }, ?! E2 P" S  J5 @
<DIV class=text4>F--short，</DIV>2 A/ \& h/ r2 n9 K$ g" o0 L2 l
<DIV class=text4>H--int，</DIV>
; C2 A9 i5 w2 ], W5 e<DIV class=text4>I--unsigned int，</DIV>
7 l9 j" Y. D' ]  `<DIV class=text4>J--long，</DIV>
% Q: [6 Y, R1 K0 |<DIV class=text4>K--unsigned long，</DIV>  W" \& N% h3 x, e
<DIV class=text4>M--float，</DIV>
$ A4 ^! O6 v5 F3 v+ N8 a/ j<DIV class=text4>N--double，</DIV>
; c' B* u$ l* z' P<DIV class=text4>_N--bool，</DIV>0 Y, @# ?! H$ m0 P! ~$ b
<DIV class=text4>....</DIV>+ m; m) c0 R5 o( N
<DIV class=text4>A--表示指针，后面的代号表明指针类型，如果相同类型的指针连续出现，以"0"代替，一个"0"代表一次重复；</DIV>, C! W: a$ O$ x+ r; ^. I
<DIV class=text4>4、参数表的第一项为该函数的返回值类型，其后依次为参数的数据类型,指针标识在其所指数据类型前； </DIV>( `/ A- F" P2 f) e1 F* J
<DIV class=text4>5、参数表后以"@Z"标识整个名字的结束，如果该函数无参数，则以"Z"标识结束。</DIV>
) V( z: a9 N4 E( `<DIV class=text4>其格式为"?functionname@@YG*****@Z"或"?functionname@@YG*XZ"，例如</DIV>; M6 p# q) u, @4 y! u: X4 z  p3 R
<DIV  width="100%"><RE>          int Test1（char *var1,unsigned long）-----“?Test1@@YGHPADK@Z”
  g# n, I, j0 T: t: u5 F          void Test2（）                       -----“?Test2@@YGXXZ”5 T" _/ A) S7 _3 {' n* b: ^& \
</PRE></DIV>
: |$ Q, a, w6 ^, Y<DIV class=text4>__cdecl调用约定：</DIV>( A9 n0 b3 q" ~9 e4 b) D6 B# L) w
<DIV class=text4>规则同上面的_stdcall调用约定，只是参数表的开始标识由上面的"@@YG"变为"@@YA"。</DIV>
: e0 N5 [# R  [" `' k6 ]1 p<DIV class=text4>__fastcall调用约定：</DIV>
% j1 O! Q6 L0 ^' A* x<DIV class=text4>规则同上面的_stdcall调用约定，只是参数表的开始标识由上面的"@@YG"变为"@@YI"。</DIV>
% X& k1 O) }' a<DIV class=text4>VC++对函数的省缺声明是"__cedcl",将只能被C/C++调用. </DIV>1 o$ L( M" k+ x1 B
<HR color=#cccccc SIZE=1>; @: Z8 F) }' v, `# K. P9 I5 y
; R' Q2 Z2 I- ?9 L# a: C
<DIV class=text2>关于DLL的函数</DIV>
1 @- \. q$ l  Z<DIV class=text4></DIV>/ g! m6 l4 Y9 U  W% V2 T
<DIV class=text4>动态链接库中定义有两种函数：导出函数(export function)和内部函数(internal function)。导出函数可以被其它模块调用，内部函数在定义它们的DLL程序内部使用。</DIV>7 e" w- o2 U1 g; g9 x: @% x. w
<DIV class=text4>输出函数的方法有以下几种：</DIV>
- B" W! d, g2 \7 T% h- {<DIV class=text4>1、传统的方法</DIV>
3 k- z& b2 J0 z! `<DIV class=text4>在模块定义文件的EXPORT部分指定要输入的函数或者变量。语法格式如下：</DIV>( J) O' M0 j$ N9 ^" u
<DIV  width="100%"><RE>entryname[=internalname] [@ordinal[NONAME]] [DATA] [PRIVATE]) ~$ `& m1 O( l, R: H  ?' ~5 V
</PRE></DIV>! p+ j4 @( F+ e9 _( f3 f' N
<DIV class=text4>其中：</DIV>  N( Q5 C- w8 l" y; J6 Q6 t
<DIV class=text4>entryname是输出的函数或者数据被引用的名称；</DIV>
6 t4 }5 J+ b2 o" r3 x6 S$ R<DIV class=text4>internalname同entryname;</DIV>3 r( j0 z& |  J
<DIV class=text4>@ordinal表示在输出表中的顺序号(index)；</DIV>0 ~7 G' P% c2 C- G5 M
<DIV class=text4>NONAME仅仅在按顺序号输出时被使用（不使用entryname）；</DIV>/ y+ `1 K9 K, m( u0 F1 F' @
<DIV class=text4>DATA表示输出的是数据项，使用DLL输出数据的程序必须声明该数据项为_declspec(DLLimport)。</DIV>
  T- g$ N% `( i/ I<DIV class=text4>上述各项中，只有entryname项是必须的，其他可以省略。</DIV>5 J) i' I4 h- M8 z
<DIV class=text4>对于"C"函数来说，entryname可以等同于函数名；但是对"C++"函数（成员函数、非成员函数）来说，entryname是修饰名。可以从.map映像文件中得到要输出函数的修饰名，或者使用DUMPBIN /SYMBOLS得到，然后把它们写在.def文件的输出模块。DUMPBIN是VC提供的一个工具。</DIV>$ ]+ P  f9 b+ X# ?  K* F
<DIV class=text4>如果要输出一个"C++"类，则把要输出的数据和成员的修饰名都写入.def模块定义文件。</DIV>
( U! a7 V3 S3 }3 i) p5 _; k. `1 a<DIV class=text4>2、在命令行输出</DIV>
3 }9 L" i$ K7 p* D  D4 `<DIV class=text4>对链接程序LINK指定/EXPORT命令行参数，输出有关函数。</DIV>5 A, Q, p2 N3 d; S- m! Z* L5 t
<DIV class=text4>3、使用MFC提供的修饰符号_declspec(DLLexport)</DIV>3 b9 ?, b! |. S" p
<DIV class=text4>在要输出的函数、类、数据的声明前加上_declspec(DLLexport)的修饰符，表示输出。__declspec(DLLexport)在C调用约定、C编译情况下可以去掉输出函数名的下划线前缀。extern "C"使得在C++中使用C编译方式成为可能。在"C++"下定义"C"函数，</DIV>
% m& S6 W3 l5 X6 T<DIV class=text4>需要加extern "C"关键词。用extern "C"来指明该函数使用C编译方式。输出的"C"函数可以从"C"代码里调用。</DIV>( C# ?. |2 i) h2 Z/ Z0 X. i) j$ Z
<DIV class=text4></DIV>1 s& ]+ q+ }, H+ Q
<DIV class=text4>例如，在一个C++文件中，有如下函数：</DIV>; q* j% s* Q( V0 v2 _
<DIV  width="100%"><RE>    extern "C" {void  __declspec(DLLexport) __cdecl Test(int var);}* f. U; [0 P3 U2 j
</PRE></DIV>
( G0 D* u, U5 N, x8 m# n<DIV class=text4>其输出函数名为：Test </DIV># ^$ x0 ^) Q, Y: b* u4 h
<DIV class=text4></DIV>$ G$ J$ X5 L) J% P% u: U4 }
<DIV class=text4>MFC提供了一些宏，就有这样的作用。</DIV>2 O6 U3 n  E. S
<DIV  width="100%"><RE>AFX_CLASS_IMPORT：__declspec(DLLexport)
; \/ V0 ]8 P: D8 x& C6 o : N8 V1 g) S$ h1 s4 x# o" C
AFX_API_IMPORT：__declspec(DLLexport)
) x; v1 C) z' Q  o0 z : f2 c* J# Z, d) ~9 R+ K
AFX_DATA_IMPORT：__declspec(DLLexport)
- \# m: h0 _- o ' j2 q& r* q, O; u7 f( C5 L: \
AFX_CLASS_EXPORT：__declspec(DLLexport)( K" p1 P/ ]( @; S5 d) H) b) j5 |
; U' i7 r) p' h3 W' e" w) b( w
AFX_API_EXPORT：__declspec(DLLexport)
9 X, [! P  f$ B  X' K
; o% y/ G2 T/ X( [AFX_DATA_EXPORT：__declspec(DLLexport)# Y& H; y' i( S/ @- {/ n: }; y

! |9 w' w% F# O5 o7 y9 kAFX_EXT_CLASS： #ifdef _AFXEXT
. c' q! S6 m# \7 O4 D                        AFX_CLASS_EXPORT
0 m4 a! i' Y5 a4 Q, Y" E# q               #else5 T5 |5 ]/ W5 V
                        AFX_CLASS_IMPORT: Q  n  I% E8 Q" p& @4 X. q0 e
8 u( k$ @: e$ [; i. w3 b+ T
AFX_EXT_API：#ifdef _AFXEXT  b5 I' B! y3 ~4 H1 W* V
                         AFX_API_EXPORT( y2 O. T. @+ W% T( d* I3 t* v
            #else
9 a# e! W0 [1 g4 v" H9 R9 E                         AFX_API_IMPORT
/ k+ B% \% n' J: k! [3 I
1 @. n  V0 F4 w( U0 I2 [+ ?AFX_EXT_DATA：#ifdef _AFXEXT
# Y8 B# O: e: c* y7 u6 o9 m                          AFX_DATA_EXPORT/ o7 p! t, `. B* \8 b) |
             #else
! K2 c  h7 \) ]" ?3 A                          AFX_DATA_IMPORT8 _  m- H& U; [) x6 z, P, E/ ]5 _, z/ p
</PRE></DIV>
8 F9 M8 X' O9 j6 H, Y4 c5 ?+ e6 K<DIV class=text4>像AFX_EXT_CLASS这样的宏，如果用于DLL应用程序的实现中，则表示输出（因为_AFX_EXT被定义，通常是在编译器的标识参数中指定该选项/D_AFX_EXT）；如果用于使用DLL的应用程序中，则表示输入（_AFX_EXT没有定义）。</DIV>
7 C* n- P  e. o4 [* a! J) W<DIV class=text4>要输出整个的类，对类使用_declspec(_DLLexpot)；要输出类的成员函数，则对该函数使用_declspec(_DLLexport)。如：</DIV>
) }# A2 f6 S; O: q- M<DIV  width="100%"><RE>class AFX_EXT_CLASS CTextDoc : public CDocument3 S! L0 M' ^/ T" [' q2 ~
{
+ \% N; J6 C" M- M; T8 R5 y        …. @* _( x; s1 {+ }' q
}
5 r; g8 b. s, s% r: X7 v# k
2 ^9 p2 A. p4 \9 v- A1 b6 h# f* Uextern "C" AFX_EXT_API void WINAPI InitMYDLL();
2 w) @3 I, _1 S/ x! ^1 f</PRE></DIV>
: F6 b6 c# g1 [<DIV class=text4>这几种方法中，最好采用第三种，方便好用；其次是第一种，如果按顺序号输出，调用效率会高些；最次是第二种。 </DIV>: J* @7 ^' F0 F! s( l  a: V8 m. b
<HR color=#cccccc SIZE=1>
) R. }4 N8 o9 ^+ `! V- V
8 T  E( B, o- W<DIV class=text2>模块定义文件(.DEF)</DIV>' E; N% ]4 ^6 `$ G% a# Q
<DIV class=text4></DIV>
6 _; ?5 W. R5 E. D$ Q8 Q! z<DIV class=text4>模块定义文件(.DEF)是一个或多个用于描述DLL属性的模块语句组成的文本文件，每个DEF文件至少必须包含以下模块定义语句：</DIV>
( B6 N* S' g  Y8 l% E<DIV class=text4>* 第一个语句必须是LIBRARY语句，指出DLL的名字；</DIV>: P9 P. U$ k( C# c0 C# ?% N
<DIV class=text4>* EXPORTS语句列出被导出函数的名字；将要输出的函数修饰名罗列在EXPORTS之下，这</DIV>
0 A2 G9 V7 P2 n<DIV class=text4>个名字必须与定义函数的名字完全一致，如此就得到一个没有任何修饰的函数名了。</DIV>- j$ t0 x; Y6 J* p7 O& I0 D0 j
<DIV class=text4>* 可以使用DESCRIPTION语句描述DLL的用途(此句可选)；</DIV>
# ^( k; a* D- ^+ i2 e8 {; V<DIV class=text4>* ";"对一行进行注释(可选)。</DIV>
! n$ x( Y3 d' @+ z<HR color=#cccccc SIZE=1>7 v1 }1 D- O, W3 c- S( g1 }

, @; ]$ y  o6 [+ G<DIV class=text2>DLL程序和调用其输出函数的程序的关系</DIV>- K) ~5 h: G. k1 a. t3 i
<DIV class=text4></DIV>* B1 j( A) j& A- W: G: J
<DIV class=text4>1、DLL与进程、线程之间的关系</DIV>& e+ I. q' q# d8 ]' Z1 X7 H4 {4 Q
<DIV class=text4>DLL模块被映射到调用它的进程的虚拟地址空间。</DIV>5 Z8 a# B5 l- K4 f/ H' X7 ~  X
<DIV class=text4>DLL使用的内存从调用进程的虚拟地址空间分配，只能被该进程的线程所访问。</DIV>
! v4 G$ P. ]; L- N<DIV class=text4>DLL的句柄可以被调用进程使用；调用进程的句柄可以被DLL使用。</DIV>
4 K3 w" j- I) j<DIV class=text4>DLL使用调用进程的栈。</DIV>$ o% z' W5 r2 p2 w# l
<DIV class=text4>2、关于共享数据段</DIV>
# W2 U1 D  A: \" {  y0 l9 U6 R; Q<DIV class=text4>DLL定义的全局变量可以被调用进程访问；DLL可以访问调用进程的全局数据。使用同一DLL的每一个进程都有自己的DLL全局变量实例。如果多个线程并发访问同一变量，则需要使用同步机制；对一个DLL的变量，如果希望每个使用DLL的线程都有自己的值，则应该使用线程局部存储(TLS，Thread Local Strorage)。</DIV>9 L9 m2 a# J) f$ e0 X$ ]
<DIV class=text4>在程序里加入预编译指令，或在开发环境的项目设置里也可以达到设置数据段属性的目的.必须给这些变量赋初值,否则编译器会把没有赋初始值的变量放在一个叫未被初始化的数据段中。</DIV>3 _$ f  c" A$ z; K. h
<HR color=#cccccc SIZE=1>
8 `; S; i+ d1 E7 Z( q2 I; O& E( D6 G
<DIV class=text2>作者</DIV>
& h( c& _/ v4 ]9 |<DIV class=text4></DIV>
  X$ o# \$ ?/ ^% w3 a<DIV class=text4>姜山 2002年11月7日</DIV>  o; W4 C. G$ C9 b! i

. Z- x" B  C+ o* l# }3 o# r1 j( L<DIV ><b>作者Blog：</b><a href="http://blog.csdn.net/laiyiling/" target="_blank" >http://blog.csdn.net/laiyiling/</A></DIV>
3 T. J; |3 F( P, L! i<DIV ><b>相关文章</b></DIV>. A2 \* M' ]+ z" {: D1 D
<TABLE>
2 H/ G2 S3 |! `6 Q6 S- W: c0 ^, F, {/ ^. D
<TR>  I, x4 G* ^. M6 z
<TD><a href="http://dev.csdn.net/article/36/article/36/36360.shtm" target="_blank" >DLL(Dynamic Link Libraries)专题(转帖)</A> </TD></TR>
9 C, e" j# ?  Q  l: e<TR>  B0 p& t3 z9 b2 C
<TD><a href="http://dev.csdn.net/article/36/article/34/34547.shtm" target="_blank" >让对话框对UPDATE_COMMAND_UI生效</A> </TD></TR>  j  o  V* Q( h8 }$ U
<TR>
( `, _; @% H6 u* J2 O<TD><a href="http://dev.csdn.net/article/36/article/33/33252.shtm" target="_blank" >创建可变大小的CDialog Bar</A> </TD></TR>1 V) n' ~  C9 k) T  W
<TR>
: o/ G5 e) \! [<TD><a href="http://dev.csdn.net/article/36/article/32/32900.shtm" target="_blank" >VC编译优化设置</A> </TD></TR>
# H0 c2 ]% g* R3 [, m$ d<TR>
) }4 d3 d" N3 w<TD><a href="http://dev.csdn.net/article/36/article/32/32184.shtm" target="_blank" >关于VC中的时间函数讨论</A> </TD></TR></TABLE>



欢迎光临 数学建模社区-数学中国 (http://www.madio.net/) Powered by Discuz! X2.5