动态链接库编程（一）-stug1980-ChinaUnix博客

stug1980

首页　| 　博文目录　| 　关于我

stug1980

博客访问： 205619
博文数量： 264
博客积分： 6010
博客等级：准将
技术积分： 2740
用户组：普通用户
注册时间： 2009-06-03 13:25

文章分类

全部博文（264）

未分配的博文（264）

文章存档

2011年（1）

2009年（263）

我的朋友

相关博文

动态链接库编程（一）

分类： C/C++

2009-06-04 13:19:36

Windows的动态链接库原理　

　　动态链接库 (DLLs)是从C语言函数库和Pascal库单元的概念发展而来的。所有的C语言标准库函数都存放在某一函数库中，同时用户也可以用LIB程序创建自己的函数库。在链接应用程序的过程中，链接器从库文件中拷贝程序调用的函数代码，并把这些函数代码添加到可执行文件中。这种方法同只把函数储存在已编译的.OBJ文件中相比更有利于代码的重用。
" Y% I+ o( y) W
　　但随着Windows这样的多任务环境的出现，函数库的方法显得过于累赘。如果为了完成屏幕输出、消息处理、内存管理、对话框等操作，每个程序都不得不拥有自己的函数，那么Windows程序将变得非常庞大。Windows的发展要求允许同时运行的几个程序共享一组函数的单一拷贝。动态链接库就是在这种情况下出现的。动态链接库不用重复编译或链接，一旦装入内存，Dlls函数可以被系统中的任何正在运行的应用程序软件所使用，而不必再将DLLs函数的另一拷贝装入内存。　

10.1.1 动态链接库的工作原理　2 W- r9 q0 U7 l0 }% {" f
' Y5 w, |/ `  a& f8 H1 Y" H8 R
　　“动态链接”这几字指明了DLLs是如何工作的。对于常规的函数库，链接器从中拷贝它需要的所有库函数，并把确切的函数地址传送给调用这些函数的程序。而对于DLLs，函数储存在一个独立的动态链接库文件中。在创建Windows程序时，链接过程并不把DLLs文件链接到程序上。直到程序运行并调用一个DLLs中的函数时，该程序才要求这个函数的地址。此时Windows才在DLLs中寻找被调用函数，并把它的地址传送给调用程序。采用这种方法，DLLs达到了复用代码的极限。

　　动态链接库的另一个方便之处是对动态链接库中函数的修改可以自动传播到所有调用它的程序中，而不必对程序作任何改动或处理。

　　DLLs不仅提供了函数重用的机制，而且提供了数据共享的机制。任何应用程序都可以共享由装入内存的DLLs
管理的内存资源块。只包含共享数据的DLLs称为资源文件。如Windows的字体文件等。　% a* y+ u+ \5 C$ D4 a" ^) ]
! ^# F$ p$ V% c. {8 Z
10.1.2 Windows系统的动态链接库　
! e0 S- a/ I1 J3 a  {, Q
　　Windows本身就是由大量的动态链接库支持的。这包括Windows API函数 ( KRNLx86.EXE，USER.EXE，GDI.EXE，…)，各种驱动程序文件，各种带有.Fon和.Fot 扩展名的字体资源文件等。Windows还提供了针对某一功能的专用DLLs，如进行DDE编程的ddeml.dll，进行程序安装的ver.dll等。
' m! r2 ^. \# {& N: ^7 G1 g, F/ A- I
　　虽然在编写Windows程序时必然要涉及到DLLs，但利用Delphi ，用户在大部分时候并不会注意到这一点。这一方面是因为Delphi提供了丰富的函数使用户不必直接去使用Windows API;另一方面即使使用Windows API，由于Delphi把API函数和其它Windows DLLs函数重新组织到了几个库单元中，因而也不必使用特殊的调用格式。所以本章的重点放在编写和调用用户自定义的DLLs上。

　　使用传统的Windows编程方法来创建和使用一个DLLs是一件很令人头痛的事，正如传统的Windows编程方法本身就令人生畏一样。用户需要对定义文件、工程文件进行一系列的修改以适应创建和使用DLLs的需要。Delphi的出现，在这一方面，正如在其它许多方面所做的那样，减轻了开发者的负担。更令人兴奋的是Delphi 利用DLLs 实现了窗体的重用机制。用户可以将自己设计好的窗体储存在一个DLLs中，在需要的时候可随时调用它。　
: W& Z  w3 P2 o/ k# t
10.2 DLLs的编写和调用　1 q+ a" v3 w' L: ~

10.2.1 DLLs的编写　- i5 e, D7 ?. }& I4 @

　　在Delphi环境中，编写一个DLLs同编写一个一般的应用程序并没有太大的区别。事实上作为DLLs 主体的DLL函数的编写，除了在内存、资源的管理上有所不同外，并不需要其它特别的手段。真正的区别在工程文件上。4 w* M6 n. x5 }$ y* J- }
7 C/ H/ R! r, k% b
　　在绝大多数情况下，用户几乎意识不到工程文件的存在，因为它一般不显示在屏幕上。如果想查看工程文件，则可以打开View菜单选择Project Source项，此时工程文件的代码就会出现在屏幕的Code Editor(代码编辑器)中。
  ]# e6 \: j0 }. e# O: u
　　一般工程文件的格式为：　) _% H4 z; n( @( k/ u8 c
" @6 a! E& N' x6 C- [
　　program　　工程标题;. r$ i( p" T' U% z8 Y, q5 n

　　uses　　　　子句;
0 e: Q; F) p4 r9 W, U
　　程序体　

　　而DLLs工程文件的格式为：　

　　library 工程标题;
+ M' t7 D; G- Y( J1 P2 i  P
　　uses 子句;, A( `  N) H4 l( t0 v
1 t8 z) y, p) t$ `) g7 m
　　exprots 子句;
( T( q4 r( t( W. H0 ]) U
　　程序体　. X) R6 s4 J" u" r

　　它们主要的区别有两点：

　　1.一般工程文件的头标用program关键字，而DLLs工程文件头标用library 关键字。不同的关键字通知编译器生成不同的可执行文件。用program关键字生成的是.exe文件，而用library关键字生成的是.dll文件；
7 t) W! J$ Z- m) s2 Q; y+ v
　　2.假如DLLs要输出供其它应用程序使用的函数或过程，则必须将这些函数或过程列在exports子句中。而这些函数或过程本身必须用export编译指令进行编译。4 ?& |# j9 X( d4 \0 z
6 v" h  u# v# {. k/ B3 E5 [
　　根据DLLs完成的功能，我们把DLLs分为如下的三类：

1.完成一般功能的DLLs；% \" q1 J+ a  ]0 l' o
0 p7 F" w5 Y) f( {* i, `: n5 P) ^
2.用于数据交换的DLLs；. p5 ]& G  g( x& J9 v$ ?$ `

3.用于窗体重用的DLLs。
- Z* y$ D, O; y" [
　　这一节我们只讨论完成一般功能的DLLs，其它内容将在后边的两节中讨论。　

10.2.1.1 编写一般DLLs的步骤　5 n8 R8 d1 e9 u. o! N

　　编写一般DLLs的步骤如下：+ f# y& c- J2 c

　　1.利用Delphi的应用程序模板，建立一个DLLs程序框架。+ l6 r& V) I( E5 p$ V# O3 c

　　对于Delphi 1.0的用户，由于没有DLLs模板，因此：; B+ A' ?1 i* O% k2 m% \3 o7 j- y

　　(1).建立一个一般的应用程序，并打开工程文件；% W) @6 @0 g) V+ z9 f

　　(2).移去窗体和相应的代码单元；: Y3 B7 Y) q/ V- V- n

　　(3).在工程文件中，把program改成library，移去Uses子句中的Forms，并添加适当的库单元（一般SysUtils、
Classes是需要的），删去begin...end之间的所有代码。

　　2.以适当的文件名保持文件，此时library后跟的库名自动修改；
7 b6 ?4 n( ~6 N9 t" ]( M
　　3.输入过程、函数代码。如果过程、函数准备供其它应用程序调用，则在过程、函数头后加上export 编译指示；4 l' P% _# R7 B" k" H) ^

　　4.建立exports子句，包含供其它应用程序调用的函数和过程名。可以利用标准指示 name 、Index、resident以方便和加速过程/函数的调用；& K6 v$ _* I2 ]5 v
) _. A! h3 ^: o1 G
　　5.输入库初始化代码。这一步是可选的；

　　6.编译程序，生成动态链接库文件。　1 l0 a8 O  }5 S2 H

10.2.1.2 动态链接库中的标准指示　+ t3 b3 d1 m6 F4 Y. h/ W% F0 p, Z

　　在动态链接库的输出部分，用到了三个标准指示：name、Index、resident。

　　1.name

　　name后面接一个字符串常量，作为该过程或函数的输出名。如：　
exports
InStr name MyInstr;

　　其它应用程序将用新名字(MyInstr)调用该过程或函数。如果仍利用原来的名字(InStr)，则在程序执行到引用点时会引发一个系统错误。

　　2.Index0 |; d) l- H* B- f+ a; L
　　Index指示为过程或函数分配一个顺序号。如果不使用Index指示，则由编译器按顺序进行分配。

　　Index后所接数字的范围为1...32767。使用Index可以加速调用过程。5 V5 b) W2 N+ j7 ], B$ b" A3 x/ L

　　3.resident# N5 {5 e. v9 u6 T

　　使用resident，则当DLLs装入时特定的输出信息始终保持在内存中。这样当其它应用程序调用该过程时，可以比利用名字扫描DLL入口降低时间开销。) W" g7 N3 `0 s0 y6 O
1 S# p0 h) @# N5 s. [% Y
　　对于那些其它应用程序常常要调用的过程或函数，使用resident指示是合适的。例如：　
exports
5 @1 V$ a3 d8 a) A; _$ Y
InStr name MyInStr resident;　; _/ t0 [  l+ m  c
/ G. G3 N; i  }
10.2.1.3 DLLs中的变量和段　6 G4 ]8 l5 j8 I! r+ A0 I1 z

一个DLLs拥有自己的数据段(DS)，因而它声明的任何变量都为自己所私有。调用它的模块不能直接使用它定义的变量。要使用必须通过过程或函数界面才能完成。而对DLLs来说，它永远都没有机会使用调用它的模块中声明的变量。
1 o6 W7 b% Y7 q. b
　　一个DLLs没有自己的堆栈段(SS)，它使用调用它的应用程序的堆栈。因此在DLL中的过程、函数绝对不要假定DS = SS。一些语言在小模式编译下有这种假设，但使用Delphi可以避免这种情况。Delphi绝不会产生假定DS = SS的代码，Delphi的任何运行时间库过程/函数也都不作这种假定。需注意的是如果读者想嵌入汇编语言代码，绝不要使SS和DS登录同一个值。　1 R- d6 u7 ~5 J0 r6 ~+ M  i9 U* k

10.2.1.4 DLLs中的运行时间错和处理　

　　由于DLLs无法控制应用程序的运行，导致很难进行异常处理，因此编写DLLs时要十分小心，以确保被调用时能正常执行。当DLLs中发生一个运行时间错时，相应DLLs并不一定从内存中移去（因为此时其它应用程序可能正在用它），而调用DLLs的程序异常中止。这样造成的问题是当DLLs已被修改，重新进行调用时，内存中保留的仍然可能是以前的版本，修改后的程序并没有得到验证。对于这个问题，有以下两种解决方法：

　　1.在程序的异常处理部分显式将DLL卸出内存；

　　2.完全退出Windows，而后重新启动，运行相应的程序。
! V  U# ]* W( `2 {4 q& [% Z
　　同一般的应用程序相比，DLL中运行时间错的处理是很困难的，而造成的后果也更为严重。因此要求程序设计者在编写代码时要有充分、周到的考虑。　7 \7 t6 r  j" M. B( n( z
+ o. ]8 C3 e/ w
10.2.1.5 库初始化代码的编写　7 v; v. D$ G% e& G
( x! N) ]& j8 O8 M$ J5 R# m! H. U
　　传统Windows中动态链接库的编写，需要两个标准函数：LibMain和WEP，用于启动和关闭DLL。在LibMain中，可以执行开锁DLL 数据段、分配内存、初始化变量等初始化工作；而WEP在从内存中移去DLLs前被调用，一般用于进行必要的清理工作，如释放内存等。Delphi用自己特有的方式实现了这两个标准函数的功能。这就是在工程文件中的begin...end部分添加初始化代码。和传统Windows编程方法相比，它的主要特色是：- k$ ?5 m  J: o6 u$ O* ]

　　1.初始化代码是可选的。一些必要的工作（如开锁数据段）可以由系统自动完成。所以大部分情况下用户不会涉及到；

　　2.可以设置多个退出过程，退出时按顺序依次被调用；/ c2 e. @( T' o& I& ~8 b
　　3.LibMain和WEP对用户透明，由系统自动调用。+ N3 O7 ^; ^6 T* {) L' `, z

　　初始化代码完成的主要工作是：& |0 c& a2 b- f+ @7 q3 p. S, b

　　1.初始化变量、分配全局内存块、登录窗口对象等初始化工作。在(10.3.2)节“利用DLLs实现应用程序间的数据传输”中，用于数据共享的全局内存块就是在初始化代码中分配的。, F/ N! {  ~4 b% F& S# O

　　2.设置DLLs退出时的执行过程。Delphi有一个预定义变量ExitProc用于指向退出过程的地址。用户可以把自己
的过程名赋给ExitProc。系统自动调用WEP函数，把ExitProc指向的地址依次赋给WEP执行，直到ExitProc为nil。: B' C- s2 Z7 _4 D, ~* S6 b

　　下边的一段程序包含一个退出过程和一段初始化代码，用来说明如何正确设置退出过程。　

复制内容到剪贴板

代码:

library Test;

{$S-}

uses WinTypes, WinProcs;

var

SaveExit: Pointer;　

procedure LibExit; far;

begin

if ExitCode = wep_System_Exit then

begin

{ 系统关闭时的相应处理 } 

end 

else

begin

{ DLL卸出时的相应处理 }

end;

ExitProc := SaveExit; { 恢复原来的退出过程指针 }

end;　

begin

{DLL的初始化工作 }

SaveExit := ExitProc; { 保存原来的退出过程指针 }

ExitProc := @LibExit; { 安装新的退出过程 }

end.

　　在初始化代码中，首先把原来的退出过程指针保存到一个变量中，而后再把新的退出过程地址赋给ExitProc。而在自定义退出过程LibExit结束时再把ExitProc的值恢复。由于ExitProc是一个系统全局变量，所以在结束时恢复原来的退出过程是必要的。
# J9 n- r# f& E+ R
　　退出过程LibExit中使用了一个系统定义变量ExitCode，用于标志退出时的状态。 ExitCode的取值与意义如下：　

表10.1 ExitCode的取值与意义$ W1 Z& L7 t' p7 O

引用:

━━━━━━━━━━━━━━━━━━━━━9 ^( l: j+ a( K: ~2 C) j6 m. M& k
取值意义' @3 d; P- A$ i
—————————————————————4 x' @1 Y% X8 m& G8 p/ W* V
4 l  {. U& U- b
　　WEP_System_Exit Windows关闭　
# W, C. F  k2 H6 X; O4 M
) k- J- l9 J- j8 M  i5 w% qWEP_Free_DLLx DLLs被卸出
7 E; I" b! C) X+ S5 _+ @━━━━━━━━━━━━━━━━━━━━━　

　　退出过程编译时必须关闭stack_checking，因而需设置编译指示 {$S-} 。　0 j9 b% b2 G0 @$ s6 i
10.2.1.6 编写一般DLLs的应用举例　

　　在下面的程序中我们把一个字符串操作的函数储存到一个DLLs中，以便需要的时候调用它。应该注意的一点是：为了保证这个函数可以被其它语言编写的程序所调用，作为参数传递的字符串应该是无结束符的字符数组类型(即PChar类型)，而不是Object Pascal的带结束符的Srting类型。程序清单如下：

复制内容到剪贴板

代码:

library Example;

uses

SysUtils,

Classes;

{返回字符在字符串中的位置}

function InStr(SourceStr: PChar;Ch: Char): Integer; export;

var

Len,i: Integer;

begin

Len := strlen(SourceStr);

for i := 0 to Len-1 do

if SourceStr[i] = ch then

begin

Result := i;

Exit;

end;

Result := -1;

end;

exports

Instr Index 1 name 'MyInStr' resident;

begin

end.

10.2.2 调用DLLs

　　有两种方法可用于调用一个储存在DLLs中的过程。
  u3 }7 w- A3 Q0 ?
　　1.静态调用或显示装载

　　使用一个外部声明子句，使DLLs在应用程序开始执行前即被装入。例如：　

　　function Instr(SourceStr : PChar;Check : Char); Integer; far; external 'UseStr';
) \, r! L, y5 A9 s, L( N
　　使用这种方法，程序无法在运行时间里决定DLLs的调用。假如一个特定的DLLs在运行时无法使用，则应用程序将无法执行。

　　2.动态调用或隐式装载

　　使用Windows API函数LoadLibray和GetProcAddress可以实现在运行时间里动态装载DLLs并调用其中的过程。

　　若程序只在其中的一部分调用DLLs的过程，或者程序使用哪个DLLs，调用其中的哪个过程需要根据程序运行的实际状态来判断，那么使用动态调用就是一个很好的选择。6 w; A3 `# A/ I8 d2 q, e* {
3 Q" ?0 g, o$ k; g
　　使用动态调用，即使装载一个DLLs失败了，程序仍能继续运行。　( E2 E/ v% L" F2 J9 v7 M
) g& V3 J  F5 f. ^! h7 t& f: C
10.2.3 静态调用
9 Z3 s1 u1 ^$ n0 r- b1 g) E
　　在静态调用一个DLLs中的过程或函数时，external指示增加到过程或函数的声明语句中。被调用的过程或函数必须采用远调用模式。这可以使用far过程指示或一个{$F +}编译指示。
, l( L6 l' e/ s% ^9 |
　　Delphi全部支持传统Windows动态链接库编程中的三种调用方式，它们是：. S9 X# A+ p* r: T
; j+ E; e4 n' s* u8 I9 h7 N
　　● 通过过程/函数名, o7 S0 Y& {/ o8 d  A, b# Y. d. v
$ X- R7 Q) E, B5 b
　　● 通过过程/函数的别名
2 c- P+ z, a4 Z. t9 E7 _- E
　　● 通过过程/函数的顺序号　
7 T6 f3 b2 B' I- t" T
　　通过过程或函数的别名调用，给用户编程提供了灵活性，而通过顺序号(Index)调用可以提高相应DLL的装载速度。　0 e, L/ J, d7 [
# Y5 [8 @$ Q  Y5 e  U
10.2.4 动态调用　
; U' C- x& E4 Y# {( d. [% _: \/ e5 ~+ h
10.2.4.1 动态调用中的API函数　- {3 f. u! z* A. @% @; |

　　动态调用中使用的Windows API函数主要有三个,即：Loadlibrary，GetProcAddress和Freelibrary。

　　 1.Loadlibrary: 把指定库模块装入内存

　　语法为：　

　　function Loadlibrary ( LibFileName :  PChar ) :  THandle;　

LibFileName指定了要装载DLLs的文件名，如果LibFileName没有包含一个路径，则Windows按下述顺序进行查找：* z' v) }% ~  z2 h
　　(1)当前目录；
　　(2)Windows目录(包含win.com的目录)。函数GetWindowDirectory返回这一目录的路径；
　　(3)Windows系统目录(包含系统文件如gdi.exe的目录)。函数GetSystemDirectory返回这一目录的路径；
　　(4)包含当前任务可执行文件的目录。利用函数GetModuleFileName可以返回这一目录的路径；. v# L( S( l- [: G0 t$ h! q$ Z. w
　　(5)列在PATH环境变量中的目录；
　　(6)网络的映象目录列表。
　　如果函数执行成功，则返回装载库模块的实例句柄。否则，返回一个小于HINSTANCE_ERROR的错误代码。错误代码的意义如下表：　2 c' x9 b) m: [
　　表10.2 Loadlibrary返回错误代码的意义' \0 f/ n3 @/ L5 I

引用:

━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━  m5 x# |% h( w
错误代码　　　　　　　　　意　　　　　　　　义; d2 @- l7 d# E" H; ^
——————————————————————————————————————
7 i0 X) W1 _+ Q5 X: ^. d  H- p; }　　　 0 系统内存不够，可执行文件被破坏或调用非法' V2 ]4 ~& ?+ j' H3 }5 [
　　　 2 文件没有被发现' I7 s: P5 d1 [" A, B/ b0 C
　　　 3 路径没有被发现
: c$ y: E9 z% |  S9 A　　　 5 企图动态链接一个任务或者有一个共享或网络保护错; z7 H3 U& W- X+ |  N( y
　　　 6 库需要为每个任务建立分离的数据段& m4 M& F/ R- {6 t5 c
　　　 8 没有足够的内存启动应用程序
  p8 X( y, t- c3 a　　 10 Windows版本不正确' x/ p9 p) R% [! I
　　　 11 可执行文件非法。或者不是Windows应用程序，或者在.EXE映
5 h/ g! o5 e. I, F! d5 Z6 G+ O0 o　　　　像中有错误
; K. ~& \, K" x- |. m. R  C; X　　　 12 应用程序为一个不同的操作系统设计(如OS/2程序)
6 T/ U: f; V8 r9 k13 应用程序为MS DOS4.0设计" \3 p/ s. Y: {/ K, j& V
　　　 14 可执行文件的类型不知道
, u( K0 A9 a% R' `" J! W2 D# k　　　 15 试图装载一个实模式应用程序(为早期Windows版本设计)
, i/ V" ]7 G$ Z- m) i16 试图装载包含可写的多个数据段的可执行文件的第二个实例
% Q) a, [+ P% j0 j2 w) r: s　　　 19 试图装载一个压缩的可执行文件。文件必须被解压后才能被装裁
& v5 S1 R/ }: C  P　　　 20 动态链接库文件非法3 O; f- @+ X! ]9 y+ Y' c
　　　 21 应用程序需要32位扩展. R8 ^8 z1 m8 {% t! _1 `
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
7 V$ a8 V: H& k) E2 ?

　　假如在应用程序用Loadlibrary调用某一模块前，其它应用程序已把该模块装入内存，则Loadlibrary并不会装载该模块的另一实例，而是使该模块的“引用计数”加1。　( a- @3 X! N- b; i
. H" m* P3 s( M( Z& Q7 R
　　2.GetProcAddress：捡取给定模块中函数的地址. g, O+ c+ J) o6 o
! ]) U1 S5 D$ [, b* D! ]# h
　　语法为：　* j7 i( u% ]9 r* ^: z& b
% T# R- {1 Q7 F9 s. o% @  u3 f" k
　　function GetProcAddress(Module: THandle; ProcName: PChar): TFarProc;　0 Y7 H, I: @4 s6 _( ]2 B
Module包含被调用的函数库模块的句柄，这个值由Loadlibrary返回。如果把Module设置为nil，则表示要引用当前模块。- l- g6 ^7 g( d$ ^& [

　　 ProcName是指向含有函数名的以nil结尾的字符串的指针，或者也可以是函数的次序值。如果ProcName参数是次序值，则如果该次序值的函数在模块中并不存在时，GetProcAddress仍返回一个非nil的值。这将引起混乱。因此大部分情况下用函数名是一种更好的选择。如果用函数名，则函数名的拼写必须与动态链接库文件EXPORTS节中的对应拼写相一致。
6 a2 L$ A( c" s7 D" e
　　如果GetProcAddress执行成功，则返回模块中函数入口处的地址，否则返回nil。1 P. V! V; ~* L- l9 o7 L, w
3.Freelibrary：从内存中移出库模块) O& Y* l1 q+ T  ^

　　语法为：　% e" x9 Q  T! Q
" t" Y" s) o2 I! {$ j+ h; H0 ~
　　procedure Freelibrary(Module : THandle);　$ N$ Q% T0 G, R' S
# f! e' A7 S5 s  h; b" X
Module为库模块的句柄。这个值由Loadlibrary返回。

　　由于库模块在内存中只装载一次，因而调用Freelibrary首先使库模块的引用计数减一。如果引用计数减为0，则卸出该模块。

　　每调用一次Loadlibrary就应调用一次FreeLibray，以保证不会有多余的库模块在应用程序结束后仍留在内存中。　

10.2.4.2 动态调用举例　
: a( e% e) q5 g% O8 [7 m
　　对于动态调用，我们举了如下的一个简单例子。系统一共包含两个编辑框。在第一个编辑框中输入一个字符串，而后在第二个编辑框中输入字符。如果该字符包含在第一个编辑框的字符串中，则标签框显示信息：“位于第n位。”，否则显示信息：“不包含这个字符。”。如图是程序的运行界面。7 q$ d$ I/ z) e1 f7 M. E  _
输入检查功能的实现在Edit2的OnKeyPress事件处理过程中，程序清单如下。　

复制内容到剪贴板

代码:

procedure TForm1.Edit2KeyPress(Sender: TObject; var Key: Char);

var

order: Integer;

txt: PChar;

PFunc: TFarProc;

Moudle: THandle;

begin

Moudle := Loadlibrary('c:\dlls\example.dll');

if Moudle > 32 then

begin

Edit2.text := '';

Pfunc := GetProcAddress(Moudle,'Instr');

txt := StrAlloc(80);

txt := StrPCopy(txt,Edit1.text);

Order := TInstr(PFunc)(txt,Key);

if Order = -1 then

Label1.Caption := '不包含这个字符 '

else

Label1.Caption := '位于第'+IntToStr(Order+1)+'位';

end;

Freelibrary(Moudle);

end;

　　在利用GetProcAddess返回的函数指针时，必须进行强制类型转换：　; k( k& G' @" R- y
Order : = TInstr ( PFunc ) ( text,Key ) ;

　　TInStr是一个定义好了的函数类型：　
type) R, A. N" W; e( W
TInStr = function( Source:  PChar ;Check: Char ) : Integer ;　
( d3 U) |7 Z$ o* H6 c3 K2 W  D
10.3 利用DLLs实现数据传输　2 y0 |+ Y% s. i. k7 [0 D
- Q' S6 [9 E' o5 y1 p
10.3.1 DLLs中的全局内存　
2 R1 F/ r% s+ k" ]! L* ~1 P' F. ^
　　Windows规定：DLLs并不拥有它打开的任何文件或它分配的任何全局内存块。这些对象由直接或间接调用DLLs的应用程序拥有。这样，当应用程序中止时，它拥有的打开的文件自动关闭，它拥有的全局内存块自动释放。这就意味着保存在DLLs全局变量中的文件和全局内存块变量在DLLs没有被通知的情况下就变为非法。这将给其它使用该DLLs的应用程序造成困难。3 H! g" v4 V+ v* @
/ S* [/ P/ t4 r  t
　　为了避免出现这种情况，文件和全局内存块句柄不应作为DLLs的全局变量，而是作为DLLs中过程或函数的参数传递给DLLs使用。调用DLLs的应用程序应该负责对它们的维护。
8 A, Y3 f; G! O/ x" o5 r5 y8 t' M* O3 G
　　但在特定情况下，DLLs也可以拥有自己的全局内存块。这些内存块必须用gmem_DDEShare属性进行分配。这样的内存块直到被DLLs显示释放或DLLs退出时都保持有效。

　　由DLLs管理的全局内存块是应用程序间进行数据传输的又一途径，下面我们将专门讨论这一问题。　+ O+ _# w6 ~. D
10.3.2 利用DLLs实现应用程序间的数据传输　  H" ?& d  H- G: l' O

　　利用DLLs实现应用程序间的数据传输的步骤为：4 x6 J" R4 Z5 Q, g. x

　　1. 编写一个DLLs程序，其中拥有一个用gmem_DDEShare属性分配的全局内存块；

　　2. 服务器程序调用DLLs，向全局内存块写入数据；
7 y' Z4 {7 H6 B9 \8 ]
　　3. 客户程序调用DLLs，从全局内存块读取数据。　; O5 c/ D- y4 X9 M; O# S
10.3.2.1 用于实现数据传输的DLLs的编写　
, q8 f3 }! Y0 _/ q) F
　　用于实现数据传输的DLLs与一般DLLs的编写基本相同，其中特别的地方是：$ q3 D/ [1 ^0 y9 E' u2 y

　　1. 定义一个全局变量句柄：　5 h3 S. Z+ h# a! n& }* h
var. q; I  b: R7 l
hMem : THandle ;
1 }* G! M! V: W# ~- L
　　2. 定义一个过程，返回该全局变量的句柄。该过程要包含在exports子句中。如：　

复制内容到剪贴板

代码:

function GetGlobalMem: THandle; export;

begin

Result := hMem;

end;

　3. 在初始化代码中分配全局内存块：7 w' D$ D6 U* r9 ~4 K5 y: E/ A
程序清单如下：　

复制内容到剪贴板

代码:

begin

hMem := GlobalAlloc(gmem_MOVEABLE and gmem_DDEShare,num);

if hMem = 0 then

MessageDlg('Could not allocate memory',mtWarning,[mbOK],0);

end.

　　num是一个预定义的常数。- Z9 Y3 \& u6 J$ |5 e2 x6 a1 \
Windows API函数GlobalAlloc用于从全局内存堆中分配一块内存，并返回该内存块的句柄。该函数包括两个参数，第一个参数用于设置内存块的分配标志。可以使用的分配标志如下表所示。
表10.3 全局内存块的分配标志$ F2 a) v+ }) R& |# k2 X; k0 y. x
- s' `9 x: K+ s( Z5 D
标志意义3 f" L6 U" T+ q) _( {# X% K

gmem_DDEShare 分配可由应用程序共享的内存
* l- n' J0 Y. L7 t. B
gmem_Discardable 分配可抛弃的内存(只与gmem_Moveable连用)
. y  l  \0 H3 h+ Q6 \
gmem_Fixed 分配固定内存  A5 h5 x$ F4 e' M* M! q
8 w0 x. _0 h1 O+ L
gmem_Moveable 分配可移动的内存
7 f6 F. G" j- r0 P* Y( p
gmem_Nocompact 该全局堆中的内存不能被压缩或抛弃
8 M" r* Z( E1 W9 m& M: S
gmem_Nodiscard 该全局堆中的内存不能被抛弃9 r9 H$ r# k9 w7 j! b2 }
' o. Q! g; |1 X# {1 M. [$ N( w, A
gmem_NOT_Banked 分配不能被分段的内存

gmem_Notify 通知功能。当该内存被抛弃时调用GlobalNotify函数) }5 K6 Q/ C9 l% j+ ^% D' K

gmem_Zeroinit 将所分配内存块的内容初始化为零
* M/ M' d" C0 \' n8 l& n% l! ^
━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━　" Q) L# j: y4 B

　　有两个预定义的常用组合是：# b1 H  m0 z2 B1 t- K  v. }! |- H

GHND = gmem_Moveable and gmem_Zeroinit
GPTK = gmem_Fixed and gmem_Zeroinit+ F" c* {3 F* Z' a6 i' R. Z

　　第二个参数用于设置欲分配的字节数。分配的字节数必须是32的倍数，因而实际分配的字节数可能比所设置的要大。

　　由于用gmem_DDEShare分配的内存在分配内存的模块终止时自动抛弃，因而不必调用GlobalFree显释放内存。

阅读(319) | 评论(0) | 转发(0) |

上一篇：用C++控制DVD/CD驱动器的开关

下一篇：贝赛尔曲线的拆分算法

给主人留下些什么吧！~~

感谢所有关心和支持过ChinaUnix的朋友们

16024965号-6