delphi21

合集下载

Delphi快捷键大全

ctrl + （向下方向键）向下滚动屏幕，光标跟随滚动不出屏幕
ctrl + （向左方向键）光标向左跳tab
ctrl + （向右方向键）光标向右跳tab
shift + 方向键选择代码
ctrl + alt + b 显示breakpoint list 窗口
ctrl + alt + c 显示cpu 窗口
ctrl + alt + l 显示local variables窗口
alt + f11 use unit 引用同一工程内的其他单元
shift + f7 trace to next source line
shift + f8 调试时弹出cpu窗口
（单步跟踪进入函数过程实现内部）
f8 step over（单步跟踪）
f9 run
ctrl + i 同tab键
ctrl + j 显示代码模板列表
ctrl + m 同enter键
ctrl + n 同enter键
ctrl + r 显示replace text窗口
ctrl + s 保存当前单元
ctrl + t 删除光标右边的一个单词
ctrl + v 粘贴
ctrl + f11 open project
alt + f4 关闭所有单元，但不关闭项目
alt + f6 同f12
alt + f10 相当于鼠标右键
Ctrl+PageUp 将光标移至本屏的第一行，屏幕不滚动。

Delphi常用关键字用法详解

Delphi常⽤关键字⽤法详解本⽂详细介绍了Delphi中常⽤的各个关键字名称及⽤法，供⼤家在编程过程中借鉴参考之⽤。

详情如下：absolute：1 2 3 4 5 6 7 8 9 10//它使得你能够创建⼀个新变量, 并且该变量的起始地址与另⼀个变量相同. varStr: string[32];StrLen: Byte absoluteStr;//这个声明指定了变量StrLen起始地址与Str相同.//由于字符串的第0个位置保存了字符串的长度, 所以StrLen的值即字符串长度. beginStr := 'abc';Edit1.Text := IntToStr(StrLen);end;abstract：12 3 4 5 6 7 8 9 10 11 12 13//它允许你创建抽象的⽅法, 包括有抽象⽅法的类称为抽象类.//Abstract关键字必须与Virtual或Dynamic关键字同时使⽤, 因为抽象⽅法必须被覆盖式实现. //抽象类不能实例化, 抽象⽅法不能包含⽅法体.typeTDemo = classprivateprotectedprocedure X; virtual; abstract;publicconstructor Create;destructor Destroy; override;publishedend;and：12 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19//⼀、表⽰逻辑与if(a>0) and(b>0) then//⼆、表⽰位运算vara,b,c: Integer;beginc := (a and b);end;//使⽤And表⽰逻辑时, And左右的表达式必须⽤⼩括号括起, 以避免以⽣条件的冲突. //例如:if a>0and b>0then//编译器可能会理解为:if a>(0and b)>0then//或:if(a>0) and(b>0) then//但是实际编译时, 编译器会产⽣⼀个冲突, 报告错误.//并且第⼀种可能包含了a>b>c的形式, 这在Delphi中不被⽀持.//所以使⽤And运算符时必须使⽤括号, 以区分左右的条件.//表⽰位运算时也必须加上括号, 将And以及左右参数括起.array：1 2 3 4 5 6 7 8 9 10 11 12//Array⽤于表⽰数组, 任何的对象都能被声明成数组.数组分为静态和动态的２种.//静态数组varArr1: array[1..10] of Integer;//动态数组, 由于声明时不知其元素个数, 所以必须在后期⽤SetLength⽅法设置数组的⼤⼩varArr2: array of Integer;//数组作为参数时, 不能传⼊数组的⼤⼩, 只能传⼊数组名, 然后⽤Length⽅法获取数组的元素个数function X(A: array of Integer): Integer;vari: Integer;12 13 14 15 16 17 18i: Integer;beginResult := 0;for i := 0to Length(A)-1do Result := Result + A[i]; end;as：12 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17//As⽤于将⼀个对象转换为另⼀个对象procedure BtnClick(Sender:TObject);begin(Sender as TButton).Caption := 'Clicked';end;//对于对象填充接⼝的转换, 必须⽤As进⾏(HTTPRIO as IExp).GetConnection;//As不能⽤于数据类型的转换, 下⾯的代码是错误的: vari: Integer;s: string;begins := (i as string);end;//正确写法是:s := string(i);asm：12 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18//Asm关键字⽤于插⼊汇编代码, 使⽤汇编代码时, 必须使⽤asm...end;的结构, ⽽⾮begin...end; function IntToHex(Value: Integer; Digits: Integer): string;asmCMP EDX, 32JBE @A1xor EDX, EDX@A1: PUSH ESIMOV ESI, ESPSUB ESP, 32PUSH ECXMOV ECX, 16CALL CvtIntMOV EDX, ESIPOP EAXCALL System.@LStrFromPCharLenADD ESP, 32POP ESIend;assembler：1 2 3//Assembler关键字⽤于⽀持早期的汇编, 如80386等.//它和Asm的区别:Asm允许使⽤Win32汇编, ⽽Assembler只允许80x86汇编, 它不允许Invoke语句的出现. function IntToHex(AValue: Int64): string; assembler;automated：12 3 4 5 6 7 8 9 10 11 12 13 14//Automated访问区分符⽤于描述⼀个⾃动类型的成员, 它能够使程序的版本向下兼容. //ComObj单元内的成员及其实例不能使⽤Automated访问区分符.typeTDemo = classautomatedStr:WideString;end;//在程序的下⼀个版本中, 将Str做了修改, 变成typeTDemo = classautomatedStr: AnsiString;end//则新版本的Str变量能够接受旧版本的WideString型数据, 并⾃动转换成AnsiString. //在实际开发中, 如果没有特殊的需要, ⼀般不⽤automated访问区分符.1415 begin：1 2 3 4 5 6 7 8 9 10 11//begin关键字⽤于表⽰⼀段程序或⼀个结构的开始, 必须⽤end关键字来结束. procedure X;beginShowMessage('A Demo');end;//⼀般的结构, 如If, For, While等也需要⽤begin关键字来标出结构起始点for i:=1to100dobeginsum := sum + i;if sum > 1000then Break;end;case：12 3 4 5 6 7 8 9 10 11 12 13 14 15 16//Case语句⽤于完成条件选择, Case语句的的被选择对象必须是有序类型, 包括整型, 枚举类型, 字符型等. //Case语句必须由end结束,如果没有相符合的选择项, 可以加⼊else来作出通⽤选择.function GetDays(AYear,AMonth: Integer): Integer;begincase AMonth of1,3,5,7,8,10,12: Result := 31;4,6,9,11: Result := 30;2: beginif IsLeapYear(AYear) thenResult:=29elseResult:=28;end;elseResult:=0;end;cdecl：1 2 3 4 5 6 7 8 9//Cdecl是函数调⽤协定的⼀种, 它规定了从C或C++编写的DLL中调⽤函数所必须遵守的规则. //它可以将C或C++中的数据类型转换为Delphi的.//例如C++中的代码:int X(int i){return i*2;}//这个函数被编译在Demo.dll中, ⽤Delphi调⽤时必须使⽤:function X(i: Integer): Integer; Cdecl; external 'Demo.dll';class：123 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21//Class关键字⽤于声明或继承⼀个类, 也可以使类和接⼝同时继承.//另外, Class关键字也能⽤于声明类通⽤⽅法, 使得⽗类可以从类内访问⼦类的⽅法. typeClassDemo = class(TObject)privatepublicconstructor Create;end;//如果⽤class声明⽅法, 则该⽅法在类与相关类中都可以使⽤, 譬如:typeClassA = classprivatepublicprocedure Y;end;typeClassB = class(ClassA)privatepublicclass procedure X;end;21 22 23 24 25 26 27 28end;//则在使⽤时ClassA能够直接访问ClassB的X⽅法procedure ClassA.Y;beginSelf.X;end;//此时⽗类将⼦类的class⽅法作为⾃⾝的⽅法进⾏调⽤.const：1 2 3 4 5 6 7 8//Const关键字⽤于声明常量, 使⽤const声明的数据将不能在程序中被改变.//也可以⽤来声明函数参数, ⽤const指定的参数不允许在函数中改变.const MyFileName = 'Delphi';const MyInteger = 100;//⽤Const声明常量不需要指出其数据类型, 系统会⾃动判断类型, 并作⾃动调整. //函数中可以⽤const声明不可更改的参数function X(const i: Integer): string;//此时在函数操作过程中, i的值不可改变.constructor：12 3 4 5 6 7 8 9 10 11 12 13//constructor关键字⽤来声明⼀个类的构造函数, 当类被实例化时, ⾸先调⽤此函数//构造函数⼀般⽤Create表⽰, Create⽅法能够连带类中存在的CreateWnd⽅法. typeClassDemo = class(TObject)privatefValue: Integer;publicconstructor Create;end;constructor ClassDemo.Create;beginfValue := 0;end;contains：1 2 3 4 5 6 7 8//Contains关键字指出了某个包(Package)是否包含某个⽂件.//⽤Contains引⼊的⽂件必须被添加到包⽂件中, 它可以避免关键⽂件的引⽤丢失. package DATAX;requiresrtl, clx;containsDb, DBLocal, DBXpress;end.default：1 2 3 4 5 6 7 8 9 10 11//Default关键字⽤于指出⼀个属性的默认值//只有有序类型的属性才允许默认值的存在, 否则必须在构造函数中初始化属性值. typeClassDemo = classprivatefValue: Integer;publishedproperty Value: Integer read fValue write fValue default 0;end;//它也可以指出⼀个类的默认属性property strings[Index: Integer]: string read GetString write PutString; Default;destructor：1 2 3 4 5 6 7 8//Destructor⽤于标识析构函数, 析构函数在类被释放时⾃动调⽤.//析构函数只允许覆盖, 再不允许重载.析构函数通常⽤Destroy作为函数名. typeClassDemo = class(TComponent)publicdestructor Destroy;override;end;//由于TComponent类中也有Destroy⽅法, 所以要将其重写9 10//但是若要重载析构函数, 则不允许, 下⾯代码是错误的: destructor Destroy; overload;dispid：1 2 3 4 5 6 7 8 9 10 11 12 13 14 15//DispId关键字被⽤在DispInterface接⼝中, ⽤于指定特定的适配序号. //在DispInterface接⼝中, 适配序号必须是唯⼀的,//如果不指定DispId, 则系统会⾃动分配适配序号给接⼝内每⼀个⽅法. //可以通过适配序号访问DispInterface接⼝中的⽅法.typeIStringsDisp = dispinterface['{EE05DFE2-5549-11D0-9EA9-0020AF3D82DA}']property ControlDefault[Index: Integer]: Olevariant dispid 0; default; function Count: Integer; dispid 1;property Item[Index: Integer]: Olevariant dispid 2;procedure Remove(Index: Integer); dispid 3;procedure Clear; dispid 4;function Add(Item: Olevariant): Integer; dispid 5;function_NewEnum: IUnknown; dispid -4;end;dispinterface：1 2 3 4 5 6 7//DispInterface⽤于声明⼀个特定的适配器接⼝, 这个适配器能够接受标准系统接⼝中传⼊传出的数据. //⽤DispInterface声明的接⼝不能被继承, 只能够被引⽤.//DispInterface中⽅法只能调⽤, 并且必须被动态绑定.//可以通过DispId为接⼝内⽅汉分配适配序号.//DispInterface仅能⽤于Windows平台, 如果在Linux下进⾏开发, 则此关键字会⾃动被系统屏蔽.//通常情况下, 不使⽤DispInterface.//实例请参见DispIddiv：1 2 3 4 5 6 7//Div⽤于求两数之整数商.⽤于Div运算的两个数值必须均为整型, 其运算结果也为整型. vara,b,c:Integer;begina := 20;b := 3;c := a div b; {6}end;do：12 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25//Do关键字⽤于For, While, On, With语句, 构成特定的结构//For语句:for i := 1to100do sum:=sum+i;//While语句:while i < 100dobegin　sum := sum + i;　Inc(i);end;//On语句(异常处理):try　i := StrToInt(s);except　on exception do ShowMessage('Error!');end;//With语句:with Memo1.Lines dobegin　Clear;　Append('abc');　Append('123');end;downto：1 2 3 4//DownTo关键字⽤于For语句, 指明循环变量是递减的.for i := 100downto1doListBox1.Items.Add(IntToStr(i));//在For语句中, 循环变量递增⽤To关键字, 递减⽤DownTo关键字.dynamic：1 2 3//Dynamic⽤于声明⼀个动态的⽅法,//动态⽅法可以被覆盖, 并且可以使代码⼤⼩尽可能的减少(区别于Virtual). procedure X(i: Integer); dynamic;else：123 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25//else⽤于引导程序的运⾏⽅向, 它可以与If, Case和On语句联⽤, 当条件不满⾜时, 转到else下运⾏//If语句(在If语句中, else前不允许有分号):if a > b thenc := aelsec:=b;//Case语句:case Tag Of1:Result:=1;2:Result:=2;3:Result:=3;elseResult:=0;end;//On语句(异常处理):tryi := StrToInt(s);Excpeton EZeroDivide do Result := 1;on EOverflow do Result := 2;elseResult := 0;end;end：12 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22//End⽤于结束⼀个语句块或是⼀个单元.//它可以与begin, Case, Class, Interface, Asm, Unit, Package等相匹配. //对于语句块(局部结束), End后必须添加分号.//⽽对于单元或包(全局结束), end后必须添加句号.//在If语句中else关键字前的End后不允许添加符号.procedure X;begin　with Button1 do　begin if Button1.ShowHint then Button1.Caption := 'Hinted' else Button1.Caption := 'Not Hinted';　end;end;//在包内使⽤End来结束:package DATAX;requiresrtl,clx;contains Db, DBLocal, DBXpress;end.except：1 2 3 4//except关键字⽤于异常处理, 必须⽤在try语句内, 如果发⽣异常, 则执⾏except后的语句tryi := StrToInt(s);except4 5 6exceptShowMessage('Error!'); end;export：1 2 3 4 5//Export标明了函数调⽤协定, 指出函数可以被输出, 输出的函数能被本地或远程调⽤.//其他程序可以⽤dll的形式调⽤程序内的函数.它是向下兼容的.function Add(a,b: Integer): Integer; export;//如果这个程序被编译为Demo.exe, 并且另⼀个程序需要调⽤这个函数, 可以使⽤以下语句function Add(a,b: Integer): Integer; stdcall; external 'Demo.exe';exports：123 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32//exports⽤于输出对象, 它必须被⽤在接⼝和实现之间, 可以同时输出多个项, 项与项之间⽤逗号分开. libraryDemo;function X(i: Integer): string; stdcall;begin　Result:=IntToStr(i);end;exports　X;beginend.//如果输出的对象被重载, 则必须给对象起个别名, 并注明参数.library Demo;function X(i: Integer): string; overload; stdcall;begin　Result := IntToStr(i);end;function X(s: string): Integer; overload; stdcall;begin　Result := StrToInt(s);end;exportsX(i: Integer) name 'x1',X(s: string) name 'x2';beginend.external：1 2 3 4 5 6 7 8 9 10 11//External关键字⽤于引⽤⼀个外部的或是OBJ内的⽅法.{$L Demo.OBJ}procedure X(i:Integer);external;//如果是从dll或外部程序中引⽤, 则可以使⽤以下代码:function A(FileName: string): string; external 'Demo.dll';//如果被引⽤的函数被重载, 则必须另外指出引⽤的名称.function A(Name: string): string; overload; stdcall; external 'Demo.dll'name 'A1'; function A(Code: Integer): string; overload; stdcall; external 'Demo.dll'name 'A2';//使⽤External关键字时, 必须注意⼤⼩写, 否则将出现错误.far：1 2 3 4 5//Far标明了函数调⽤协定, 指出函数可以被远程调⽤.//其他程序可以⽤dll的形式调⽤程序内的函数.它是向下兼容的.functionAdd(a,b: Integer): Integer; Far;//如果这个程序被编译为Demo.exe, 并且另⼀个处于其他计算机的程序需要调⽤这个函数, 可以使⽤以下语句: function Add(a,b: Integer): Integer; stdcall; external 'Demo.exe';file：1 2 3 4 5 6 7 8 9//File关键字指出了⽂件操作类型, ⽂件必须被声明为File,//如果在File后追加Of和⽂件类型, 则⽂件可以被定义为读写指定类型数据. typeTPerson = recordPName: string[32];PAge: Integer;end;varPFile: file of TPerson;finalization：1 2 3 4 5 6 7//finalization关键字标识了单元被释放时所要调⽤的⽅法, //通常是释放掉单元中不能⾃动释放的对象, 也可以不⽤. //finalization最常⽤的情况是对OLE对象做反初始化. initializationActiveX.OleInitialize(nil);finalizationActiveX.OleUninitialize;finally：1 2 3 4 5 6 7 8//finally关键字指出了异常处理中最后必须要调⽤的⽅法,//不论是否发⽣异常, finally后的语句总是在try语句结束时执⾏. tryNode := Node.GetNext;Edit1.Text := Node.Text;finally　Node := nil;end;for：1 2 3 4//For关键字引出For循环结构, ⽤于做指定次数的循环. for i := 1to100dosum := sum + i;//如果循环变量是递减的, 则可以⽤DownTo关键字for i := 100downto1do Inc(sum);forward：12 3 4 5 6 7 8 9 10 11 12 13 14 15//Forward关键字⽤于⽅法的前置定义.只定义⽅法声明, 然后在程序的后⾯对⽅法进⾏实现.//这么做有利于代码的可读性, 可以将所有的声明放在⼀起, 然后将所有的实现也放在⼀起. function X(i: Integer): Integer; forward;procedure Y(s: string); forward;...function X;beginResult := i * 2;end;procedure Y;beginWriteLn(s);end;//⽤Forward前置声明的⽅法在实现时不需要再输⼊⽅法的参数和返回值, 直接使⽤⽅法名即可.function：1 2 3 4 5 6 7//Function⽤于声明函数functionX(i: Integer): Integer;//它也可以⽤于动态函数的声明type　TFun = function(i: Integer): Integer of object;//动态声明时, 不需要指出函数名, 只需要指出参数和返回类型就可以, 具体的函数名可以在后期绑定.goto：12 3//Goto语句⽤在跳转⾏号, 可以跳转到当前结构层内任意位置. //必须在声明处⽤label关键字声明⾏号.4 5 6 7 8 9 10 11 12 13 14 15 16 17//由于Goto语句会破坏程序的结构, 不推荐使⽤. var　a,b: Integer;label　X,Y;begin　if a > b then goto X　else goto Y;X:　WriteLn('a > b');Y:　WriteLn('b > a');end;if：12 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20//If关键字引出If条件语句, ⽤于对条件进⾏判断.var　a,b: Integer;begina := 2;b := 3;　if a>b then WriteLn('a='+ IntToStr(a))　else WriteLn('b='+ IntToStr(b));end;//If语句的通常结构是If...Then...else, else语句也可以不要.//在If语句内如果有多个⼦语句, 则必须⽤begin...End结构进⾏区分. if a > b thenbegin　WriteLn('a>b');　WriteLn('a='+ IntToStr(a));　WriteLn('b='+ IntToStr(b));Endelse　WriteLn('b>a');implementation：1 2 3 4 5 6 7 8 9 10//Implementation标识了单元中的实现部分, 单元的基本结构为://Unit...Interface...implementation...end.//函数体, 过程体等必须写在implementation关键字后.//如果在implementation后引⽤对象, 则对象是⾮公开的, 仅能供单元⾃⾝使⽤. implementationuses frmAbout;beginFormAbout.Show;end;//⼀个完整的单元必须拥有implementation部分.implements：12 3 4 5 6 7 8 9 10 11 12 13 14 15 16//Implements指出了⼀个属性从接⼝继承, 此时属性被转换成接⼝对象.//通过接⼝动态绑定属性, 并动态的设定属性值.type　IMyInterface = interface procedure P1; procedure P2;　end;　TMyImplclass = class procedure P1; procedure P2;　end;　TMyclass = class(TInterfacedObject, IMyInterface) FMyImplClass: TMyImplClass; property MyImplClass: TMyImplclass read FMyImplclass implements IMyInterface; procedure IMyInterface.P1 = MyP1; procedure MyP1;　end;17 18 19//通过implements声明后, 可以在类声明时指出接⼝中⽅法的实体, 如上例中的: procedure IMyInterface.P1 = MyP1;in：123 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28//In⽤于判断⼀个集合中是否包含某个元素.被判断的内容必须是单个集合元素和⼀个集合的实例. type　TCol = (cA,cB,cC);　TCols = set of TCol;var　Cols: TCols;begin　Cols := [cA,cB];　if cA in Cols then ShowMessage('cA in Cols')　else ShowMessage('cA not in Cols');end;//In也⽤于⼯程⽂件中, ⽤于标识某个⽂件是否被⼯程所引⽤.Uses　Unit1 in'Unit1.pas';//In可以被⽤在For语句中, ⽤于循环取出⼀个集合中的元素.var　s: string;　sl: TStringList;begin　...　for s In sl do　begin ShowMessage(s);　end;end;index：12 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24//Index⽤于在属性中标识序号, 以便⽤相同的属性⽅法(Get,Set)对不同的属性进⾏操作. type　TForm1 = class(TForm)　private function GetInfo(const Index: Integer): Longint; procedure SetInfo(const Index: Integer; const Value: Longint);　public property iLeft:Longint index 0read GetInfo write SetInfo; property iTop:Longint index 1read GetInfo write SetInfo; property iWidth:Longint index 2read GetInfo write SetInfo; property iHeight:Longint index 3read GetInfo write SetInfo;　end;function TForm1.GetInfo(const Index: Integer): Longint;begin　case Index of 0: result := self.Left; 1: Result := self.Top; 2: result := self.Width; 3: result := self.Height;　end;end;//Index关键字也⽤于在属性中指出多个元素, 例如:property Selected[Index: Integer]: Boolean read GetSelected write SetSelected;inherited：1 2 3 4 5//Inherited⽤于调⽤⽗类的⽅法.type　TDemo = class(TComponent)　public constructor Create(AOwner: TComponent); override;6 7 8 9 10 11 12 13 14 15　end;constructor TDemo.Create(AOwner: TComponent);begin　inherited Create(AOwner);end;//如果调⽤的是与⾃⾝同名的⽅法, 则也可以省去⽅法名和参数.如上例中的inherited Create(AOwner);//可以改成:Inherited;initialization：1 2 3 4 5 6 7//initialization关键字标识了单元被载⼊时所要调⽤的⽅法, //通常是初始化⼀些不能⾃动初始化的对象, 也可以不⽤. //initialization最常⽤的情况是对OLE对象做初始化. initializationActiveX.OleInitialize(nil);finalizationActiveX.OleUninitialize;inline：12 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18//InLine关键字⽤于Asm或assembler结构中,//⽤于指出该汇编语句是向下兼容的.它对于程序的编译没有任何影响. function IntToStr(Value: Integer): string;asm　InLine;PUSH ESIMOV ESI, ESPSUB ESP, 16xor ECX, ECXPUSH EDXxor EDX, EDXCALL CvtIntMOV EDX, ESIPOP EAXCALL System.@LStrFromPCharLenADD ESP, 16POP ESIend;interface：12 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25//Interface标识了单元中的接⼝部分, 单元的基本结构为://Unit...Interface...implementation...end.//函数, 过程等的声明必须写在Interface关键字后.//如果在Interface后引⽤对象, 则对象是没有实例的, 使⽤时必须被实例化. Interface　uses frmAbout;var　FAbout: TFormAbout;begin　FAbout :＝ TFormAbout.Create(Self);　FAbout.Show;end;//⼀个完整的单元必须拥有Interface部分.//Interface也可以⽤作接⼝的声明.type　IMalloc = interface(IInterface)　['{00000002-0000-0000-C000-000000000046}'] function Alloc(Size: Integer): Pointer; stdcall; function Realloc(P: Pointer; Size: Integer): Pointer; stdcall; procedure Free(P: Pointer); stdcall; function GetSize(P: Pointer): Integer; stdcall; function DidAlloc(P: Pointer): Integer; stdcall; procedure HeapMinimize; stdcall;　end;is：1 2 3 4 5 6 7 8//Is关键字⽤于对象的判断, 有某些情况下, 也可以作"As"使⽤. var　Comp: TComponent;begin...　if Comp Is TEdit then (Comp as TEdit).Text := 'Edit';end;label：12 3 4 5 6 7 8 9 10 11 12 13 14 15//label关键字⽤于声明⾏号标签, 以便⽤Goto进⾏转向, 不推荐使⽤. var　a,b: Integer;label　X,Y;begin　if a > b then goto X　else goto Y;X:　WriteLn('a>b');Y:　WriteLn('b>a');end;library：12 3 4 5 6 7 8 9 10 11 12 13 14//Library关键字⽤于指出⼀个⼯程为类库.类库编译后⽣成DLL⽂件, 可被其他程序调⽤. library Editors;uses EdInit, EdInOut, EdFormat, EdPrint;exportsInitEditors,doneEditors name done,InsertText name Insert,DeleteSelection name Delete,FormatSelection,PrintSelection name Print,SetErrorHandler;beginInitLibrary;end.message：1 2 3 4 5 6 7 8 9 10 11 12//Message关键字⽤于声明消息⽅法,//带有Message的⽅法必须指出接收的消息类型, 并通过引⽤将消息传⼊⽅法中, 以便进⾏处理. procedure Refresh(var Msg: TMessageRecordtype); messageID_REFRESH;procedure Refresh(var Msg: TMessageRecordtype);beginif Chr(Msg.Code) = #13then...elseinherited;end;//⽤户可以⾃定义消息, ⾃定义消息也能够被Message接收, 并引发事件.mod：1 2 3 4 5 6//Mod⽤于求两数之整数模, 即余数.⽤于Mod运算的两个数值必须均为整型, 其运算结果也为整型. var　a,b,c: Integer;begina := 20;b := 3;c := a mod b; {2}7end; name：1 2 3 4 5//Name关键字⽤于指出⽅法的别名,//对于⼀个要被外部引⽤的⽅法, 建议⽤Name申请⽅法别名, 以避免外部程序改动⽅法的实体内容. //从外部引⽤⼀个⽅法时, 如果该⽅法有别名, 则必须⽤Name进⾏标识.function MessageBox(HWnd: Integer; Text, Caption: PChar; Flags: Integer): Integer;stdcall; external 'user32.dll'name 'MessageBoxA';near：1 2 3 4 5//Near标明了函数调⽤协定, 指出函数可以被本地调⽤.//其他程序可以⽤dll的形式调⽤程序内的函数.它是向下兼容的.function Add(a,b: Integer): Integer; near;//如果这个程序被编译为Demo.exe, 并且另⼀个处于本地的程序需要调⽤这个函数, 可以使⽤以下语句: function Add(a,b: Integer): Integer; stdcall; external 'Demo.exe';nil：1 2 3 4 5 6//Nil⽤于表⽰⼀个空指针, 或是没有实例的对象. while Node <> nil dobegin　ListBox1.Items.Add(Node.Text);　Node := Node.GetNext;end;nodefault：12 3 4 5 6 7 8 9 10 11 12 13 14 15//NoDefault关键字指出了⼀个属性不允许有默认值, 这通常⽤在继承中.type　TClassA = class　private fValue: Integer;　published property Value: Integer read fValue write fValue default 0;　end;　TClassB = class(TClassA)　published property Value:Integer read fValue write fValue nodefault;　end;//由上例可知, TClassA中的Value有默认值0,//TClassB继承了TClassA, 所以也继承了其默认值, 在此⽤NoDefault去掉默认值not：1 2 3 4 5 6 7 8 9//Not⽤于取反, 它否定了原先的结果.例如:if a > b then//可以写成:if not(a < b) then//Not关键字通常⽤于切换Boolean型的属性procedure Button1Click(Sender: TObject); begin　StatusBar1.Visible := not StatusBar1.Visible; end;object：12 3 4 5 6 7 8 9 10 11 12//Object⽤于声明⼀个对象, 这个对象可以是任意的, 并且向下兼容.Object只能被Object所继承. //声明对象的⽅法与声明类的⽅法是相同的.type　ODemoA = object　end;　ODemoB = object(ODemoA)　end;//Object关键字还⽤于声明动态函数或过程, 例如:type　TMyFun = function(i: Integer): Integer of Object;　TMyProc = procedure(s: string) of object;1314//经过object声明的函数或过程可以被动态的绑定到指定的函数体, 或是绑定到控件是事件中. of：12 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27//Of关键⽤于和其他关键字构成指定的结构.Of可以与Case, Class, Array, File, Set, Object连⽤. //Case语句:case Tag Of　0: Result := 'a';　1: Result := 'b';end;//Class语句:type　TDemo = class of TComponent;//Array结构:var　MyInt: array of Integer;//File结构:var　MyFile: file of Byte;//Set语句:type　TCol = (cA,cB,cC);　TCols = set of TCol;//Object结构:type　MyFun = function(I: Integer): Integer of Object;on：1 2 3 4 5 6 7//On关键字⽤于异常处理, 指出发⽣的异常, 并获取异常信息. try　i := StrToInt(s);except　on E: exception do ShowMessage(E.Message);end;or：12 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21//⼀、表⽰逻辑或if(a>0) or(b>0) then//⼆、表⽰位运算vara,b,c: Integer;beginc := (a or b);end;//使⽤Or表⽰逻辑时, Or左右的表达式必须⽤⼩括号括起, 以避免以⽣条件的冲突//如果在条件语句中使⽤ Or, 则编辑器不知道⽤户使⽤Or做什么例如:if a>0or b>0then//编译器可能会理解为:if a>(0or b)>0then//或者if(a>0) or(b>0) then//但是实际编译时, 编译器会产⽣⼀个冲突, 报告错误//并且第⼀种可能包含了a>b>c的形式, 这在Delphi中不被⽀持//所以使⽤Or运算符时必须使⽤括号, 以区分左右的条件.//表⽰位运算时也必须加上括号, 将Or以及左右参数括起.out：12 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17//Out关键字说明了⽅法参数的输出⽅式, ⼀般的函数只能有⼀个返回值,//使⽤Out可以在⼀个函数中返回多个结果.//Out和var不同, Out是以返回值的形式进⾏参数返回, ⽽var是直接输⼊⼀个参数的地址. procedure X(out i: Integer; out s: string);begin　i := i * 2;　s := s + 'abc';end;procedure TForm1.Button1Click(Sender: TObject);var　i: Integer;　s: string;begin　i := 20;　s := 'xxx';　X(i,s);end;overload：12 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18//Overload关键字指出了⽤于重载的⽅法, 重载即⽅法名相同,//但是参数数量, 类型或顺序不同, 满⾜此条件的构成重载.function X(i: Integer): string; overload;function X(s: string): string; overload;//从⽗类继承时, 如果⼦类拥有和⽗类相同的⽅法, 则也必须⽤overload构成重载, //但是此类重载也必须满⾜重载的要求.type　TDemo = class(TComponent)　public procedure CreateWnd(AOwner: TWinControl); overload;　end;//如上例, ⼦类拥有的⽅法为:procedure CreateWnd; {继承⾃⽗类}procedure CreateWnd(AOwner: TWinControl); {⼦类声明}//共两个CreateWnd⽅法.//如果不使⽤重载, 则在⼦类中可以覆盖⽗类的⽅法.override：12 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20//Override⽤于覆盖⼀个Virtual或是Dynamic形式的⽅法.//覆盖时必须沿⽤被覆盖⽅法的声明, 并且不允许修改原⽅法的参数和返回类型. procedure Create(AOwner: TComponent); override;//Override多⽤于继承, ⽤⼦类覆盖掉⽗类的⽅法.type　TClassA = class procedure X; virtual;　end;　TClassB = class(TClassA) procedure X; override;　end;//如上例, ⼦类拥有的⽅法为:procedure X; {从⽗类覆盖}//⽗类拥有的⽅法为:procedure X; {⽗类⾃⾝⽅法, 未被覆盖}//如果⽗类的⽅法未⽤Virtual或Dynamic声明,//或是有修改参数的需要, 则必须⽤Reintroduce关键字进⾏覆盖.package：1 2 3 4 5//Package关键字⽤于指出⼀个⼯程为控件库.//控件库编译后⽣成BPL⽂件, 可被安装到Delphi的控件库中, 从⽽在以后的开发中使⽤控件. package DATAX;requiresrtl,6 7 8 9 clx;containsMyUnit in'C:\MyProject\MyUnit.pas'; end.packed：1 2 3 4 5 6 7//Packed关键字⽤于对结构体记录或数组进⾏打包, 打包后被打包对象的体积能显著减⼩. type　TPerson = packed Record PName: string[32]; PAge: Integer;　end;　MyArray: packed array of PChar;pascal：1 2 3 4 5 6 7//Pascal标明了函数调⽤协定,//指出函数在调⽤时遵循Pascal原因, 即先对所有的变量进⾏初始化, //避免因异步线程调⽤⽽产⽣的错误.它是向下兼容的.function X(i: Integer): Integer; Pascal;begin　Result := i * 2;end;private：1//Private标明了类内元素的访问区分权限, 被Private区分的元素只能被本类内部访问. procedure：1 2 3 4 5 6 7//Procedure⽤于声明过程procedureX(i: Integer);//它也可以⽤于动态函数的声明type　TProc = procedure(i: Integer) of object;//动态声明时, 不需要指出过程名, 只需要指出参数就可以, 具体的过程名可以在后期绑定.program：1 2 3 4 5 6 7 8 9 10 11//Program关键字⽤于指出⼀个⼯程为应⽤程序.控件库编译后⽣成exe⽂件, 可以直接执⾏program Project1;usesForms,Unit1 in'Unit1.pas';{$R *.res}beginApplication.Initialize;Application.CreateForm(TForm1, Form1);Application.Run;end.property：12 3 4 5 6 7 8 9 10 11 12 13 14 15 16//Property关键字⽤于声明属性, 属性分为显式属性和隐式属性两种,//只有声明在published访问区分符下的属性才是显式属性, 可以直接在对象查看器中查看. type　TDemo = class　Private fValue: Integr;　Published property Value: Integer read fValue write fValue;　end;//事件也是属性的⼀种, 可以在published区分符下⽤Property进⾏声明type　TOnTextChange=procedure(Sender: TObject) of object;　TDemo = class　private fEvent: TOnTexChange;　published property OntextChange: TOnTextChange read fEvent write fEvent;1718　end;protected：1//Protected标明了类内元素的访问区分权限, 被Protected区分的元素只能被本类内部和其⼦类访问. public：1//Public标明了类内元素的访问区分权限, 被Public区分的元素能够被类内和类外任何对象访问. published：1 2 3//Published标明了类内元素的访问区分权限.//被Published区分的元素能够被类内和类外任何RTTI对象访问//只在声明在Published区分符下的属性才能够成为显式属性并在对象查看器中显⽰.raise：12 3 4 5 6 7 8 9 10 11 12 13 14 15//Raise语句⽤于抛出异常,//如果希望通过外部程序处理异常, 或是在异常发⽣时重新将异常抛出, 可以使⽤Raise语句. function GetString(i: Integer): string;begin　if i < 0then raise exception.Create('Integer Cannot smaller than 0');　Result := IntToStr(i);end;//在异常处理中, 可以重新抛出异常try　i := StrToInt(s);except　on E: exception do raise exception.Create(E.Message);end;read：1 2 3 4 5 6//Read⽤于标识属性中读取所使⽤的成员或⽅法. private　fValue: Integer;published　property Value: Integer readfValue;//上例中即表明Value属性的值从fValue成员上读取.readonly：1 2 3//ReadOnly关键字⽤于标识⼀个对象是否只读.propertyReadOnly;//当ReadOnly设为True时, 不允许⽤户⼿动修改属性, 只能通过其他对象来操作.record：1 2 3 4 5 6 7//Record关键字⽤于声明⼀个结构体记录,//⼀个结构体可以视为⼀个不需要实例化的对象, 拥有⾃⼰的成员. type　TPerson = record PName: string[32]; PAge: Integer;　end;register：1 2 3 4 5 6 7//Register标明了函数调⽤协定, 指出函数在被调⽤时可以在注册表内留下记录.它是向下兼容的. functionAdd(a,b: Integer): Integer; Register; Register//关键字还⽤于向控件库或是IDE注册控件或是专家⼯具.procedure Register;begin　RegisterComponents('Sample', [TDemo]);end;reintroduce：2 3 4 5 6 7 8 9 10 11 12 13//Reintroduce⽤于重新发布⽅法, 通常⽤于继承时,//如果要覆盖的⽅法是静态⽅法, 或是需要修改⽅法的参数等, 必须⽤Reintroduce进⾏重发布. //对于Virtual或Dynamic⽅法, 可以直接⽤Override进⾏覆盖.type　TClassA = class procedure X;　end;　TClassB = class(TClassA) procedure X; reintroduce;　end;　TClassC = class(TClassB) procedure X(i: Integer); reintroduce;　end;repeat：1 2 3 4 5 6 7//repeat关键字⽤于引出repeat循环结构,//该循环必须先执⾏⼀次循环体, 然后再对循环条件进⾏判断.repeat必须与Until关键字联合使⽤.i := 0;repeat　sum := sum + i;　Inc(i);until(i >= 100);requires：1 2 3 4 5 6//Requires关键字指出了编译Package时的必备条件.若Requires的条件未满⾜, 则不允许编译包. package DATAX;requiresrtl,clx;end.resourcestring：1 2 3 4 5 6 7//ResourceString⽤于声明资源字符串, 资源字符串可以在被声明的结构内使⽤. ResourceString　CreateError = 'Cannot create file %s';　OpenError = 'Cannot open file %s';　LineTooLong = 'Line too long';　ProductName = 'Borland Rocks';　SomeResourceString = SomeTrueConstant;safecall：1 2 3 4 5//Safecall是函数调⽤协定的⼀种, 它规定了被COM调⽤的函数所必须遵守和规则. //在编译时, Safecall声明的函数被编译成COM接⼝兼容的.procedure X(s: WideString); safecall;//在编译后成为:procedure X(s: PAnsiString);set：1 2 3 4 5 6 7 8 9 10//Set关键字⽤于声明集合类, 集合类允许⽤集合运算符, 如in等进⾏操作. type　TCol = (cA,cB,cC);　TCols = set ofTCol;//操作时允许使⽤加减符号来添加或删除某个集合元素var　Cols: Tcols;begin　Cols := Cols + [cA,cB];end;shl：1 2 3 4 5//SHL表⽰向左移位, 左移的位数即乘以2的幂数var　x: Integer;begin　X := 2shl3; {16}shr：1 2 3 4 5 6//SHR表⽰向右移位, 右移的位数即除以2的幂数var　x: Integer;begin　X := 16shr2; {4}end;stdcall：1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17//Stdcall是函数调⽤协定的⼀种, 它规定了能让程序调⽤的函数所应遵守的规则. //Stdcall关键字必须在主调⽅和被调⽅之间形成配对.//例如, 被调⽅函数:Library Demo;function X(i: Integer): Integer; stdcall;begin　Result := i * 2;end;exports　X;beginend.//主调⽅函数:function X(i: Integer): Integer; stdcall; external 'Demo.dll';//同时需要注意, 使⽤Stdcall关键字时, 被调函数是⼤⼩写敏感的, 此处极容易出错.stored：1 2//Stored⽤于指出⼀个属性的值是否能被保留, 若指定了True, 则允许对属性值进⾏赋值撤销的操作. property Value: string read fValue write fValue stored True;string：1 2 3//String是⼀个数据类型, 它代表了字符串. var　Str: string;then：1 2 3 4 5 6 7 8 9//Then关键字⽤于If语句中, 当If条件成⽴时, 执⾏Then后的语句. var　a,b: Integer;begin　if a > b then WriteLn('a')　else WriteLn('b');end;threadvar：1 2 3 4 5 6//Threadvar标识了⼀个随线程启动⽽创建的变量,//如果⽤Threadvar声明变量, 则在程序结束前必须⼿动释放其占⽤的空间. threadvar S: AnsiString;S := 'ABCDEFGHIJKLMNOPQRSTUVWXYZ';S := '';//S := ''; 即释放变量S所占⽤的内存.to：1 2 3 4//To关键字⽤于For语句, 指明循环变量是递增的.for i := 10to100do　ListBox1.Items.Add(IntToStr(i));//在For语句中, 循环变量递增⽤To关键字, 递减⽤DownTo关键字.try：。

delphi控件使用

[新手必看]delphi部分的控件属性.方法.事件及常用函数的中文说明（定期更新）1． TmainMemu控件该控件是一个标准的菜单控件，运用它为窗口提供菜单。

该对象的层次结构为：TObject—TPersistent--TCompoment—TMenu。

属性1-AutoMetge：Boolean功能：用于确定非MID程序中非主Form上的菜单要不要和主Form的菜单合并。

主Form菜单AutoMerge的特性总是False。

此外，还要设置菜单项的GroupInd ex属性。

2-BiDiMode：TBiDiMode功能：控制菜单的布置模式，是从左至右，还是从右至左。

3-Handle：HMENU功能：菜单窗口句柄。

4-Images：TImagList功能：出现在菜单项左边的图像列表。

菜单项通过设置它们的ImageIndex属性，以确定图像列表中的哪—个图像出现在菜单项的左边。

5-Items：TMenuItem功能：菜单项，描述了菜单的元素。

6-OwnerDraw：Boolean功能：确定菜单项是否可以由应用程序来画。

7-ParentBiDiMode：Boolean功能：确定BiDiMode属性是否从父辈继承而来，菜单的父辈一般为Form。

方法1-GetOle2AcceleratorTabel：（var AccelTable:HAccel;var AccelCount:Int eger;Group:array of Integer）功能：返回主菜单的加速键表，其参数如下AccelTabel：设置加速键表的句柄。

AccelCount：设置加速键的总数。

Groups：即GroupIndex的值。

2-Merge：功能：组合Form上的一个主菜单与另一个非MDI应用程序的主菜单。

调用Merg e方法将另一个主菜单组合进该菜单。

参数Menu指定了要合并的菜单3-PopulateOle2Menu：（ShareMenu:HMenu; Groups:array of Integer; var W idths:array of Longint）功能：组装OLE菜单。

Delphi两种类的声明方法

Delphi两种类的声明⽅法Delphi的类声明有两种⽅法，⼀种是继承了Delphi的内建类的声明，另⼀种则是完全⾃定义的类声明。

这两种类的区别不仅在于声明程序的不同，还会影响到对象实体的内存管理。

1 unit Unit1;23 interface45 uses6 Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,7 Dialogs, StdCtrls, Buttons;89type10 TForm1 = class(TForm)11 btn1: TBitBtn;12 btn2: TBitBtn;13procedure btn1Click(Sender: TObject);14procedure btn2Click(Sender: TObject);15 p rivate16{ Private declarations }17 public18{ Public declarations }19end;2021 TMyCalss1 = class //声明⼀个继承Delphi内建类的Class类22 public23 value1:Integer;24 string1:string;25end;2627 TMyClass2 = object //声明⼀个完全⾃定义的Object类28 public29 value1:Integer;30 string1:string;31end;3233var34 Form1: TForm1;3536 implementation3738{$R *.dfm}3940procedure TForm1.btn1Click(Sender: TObject);41var42 TTest1:TMyCalss1;43begin44 TTest1 := TMyCalss1.Create; //必须使⽤其⽗类的构造⽅法4546 TTest1.value1 := 12;47 TTest1.string1:= '您好';48 ShowMessage(IntToStr(TTest1.value1) + #13 + TTest1.string1);4950 TTest1.Free; //必须使⽤其⽗类的析构⽅法5152end;53545556procedure TForm1.btn2Click(Sender: TObject);57var58 TTest2:TMyClass2;59begin6061 TTest2.value1 := 34; //不必使⽤Create的构造⽅法，可以直接构造该对象的实体，并且操作该对象的成员62 TTest2.string1 := '我好';63 ShowMessage(IntToStr(TTest2.value1) + #13 + TTest2.string1); 6465end;6667end.。

Delphi中释放介绍

Delphi中释放介绍Delphi中释放介绍2012-04-30 20:37 509人阅读评论(0) 收藏举报在delphi中，有些函数或者设置会使对象自动释放，此时如果在次释放会发生野指针的现象，导致莫名的错误。

下面介绍几种经常见到的释放规则。

（一）、使用 TObjectList[delphi] view plaincopyprint?1.procedure TForm1.Button1Click(Sender: TObject);2.var3.list: TObjectList;4.i: Integer;5.btn: TButton;6.begin7.list := TObjectList.Create;8.for i := 0 to 6 do9.begin10.btn := TButton.Create(Self);11.with btn do begin12.Caption := Format('Btn %d', [i+1]);13.Parent := Self;14.end;15.list.Add(btn);16.end;17.ShowMessage('TObjectList 释放时, 会同时释放其中的对象');18.list.Free;19.end;20.21.procedure TForm1.Button2Click(Sender: TObject);22.var23.list: TList;24.i: Integer;25.btn: TButton;26.begin27.list := TList.Create;28.for i := 0 to 6 do29.begin30.btn := TButton.Create(Self);31.with btn do begin32.Caption := Format('Btn %d', [i+1]);33.Parent := Self;34.end;35.list.Add(btn);36.end;37.ShowMessage('TList 释放后, 其中的对象并未释放');38.list.Free;39.end;（二）使用 TObjectList<T>[delphi] view plaincopyprint?1.procedure TForm1.Button1Click(Sender: TObject);2.var3.list: TObjectList<TButton>;4.i: Integer;5.btn: TButton;6.begin7.list := TObjectList<TButton>.Create;8.for i := 0 to 6 do9.begin10.btn := TButton.Create(Self);11.with btn do begin12.Caption := Format('Btn %d', [i+1]);13.Parent := Self;14.end;15.list.Add(btn);16.end;17.ShowMessage('TObjectList 释放时, 会同时释放其中的对象');18.list.Free;19.end;20.21.procedure TForm1.Button2Click(Sender: TObject);22.var23.list: TList<TButton>;24.i: Integer;25.btn: TButton;26.begin27.list := TList<TButton>.Create;28.for i := 0 to 6 do29.begin30.btn := TButton.Create(Self);31.with btn do begin32.Caption := Format('Btn %d', [i+1]);33.Parent := Self;34.end;35.list.Add(btn);36.end;37.ShowMessage('TList 释放后, 其中的对象并未释放');38.list.Free;39.end;（三）使用记录而不是记录指针[delphi] view plaincopyprint?1.{假如某个函数的参数需要一个结构指针}2.function Area(rect: PRect): Integer;3.begin4.Result := rect.Width * rect.Height;5.end;6.7.{直接声明指针并分配空间后需手动释放}8.procedure TForm1.Button1Click(Sender: TObject);9.var10.P: PRect;11.begin12.New(P);13.P^ := Rect(10, 10, 60, 50);14.ShowMessage(IntT oStr(Area(P))); //200015.Dispose(P);16.end;17.18.procedure TForm1.Button2Click(Sender: TObject);19.var20.R: TRect;21.begin22.R := Rect(10, 10, 60, 50);23.ShowMessage(IntT oStr(Area(@R))); //200024.end;（四）使用动态数组[delphi] view plaincopyprint?1.procedure TForm1.Button1Click(Sender: TObject);2.var3.arr: Array of string;4.i: Integer;5.s: string;6.begin7.for i := 0 to 3 do8.begin9.SetLength(arr, Length(arr)+1);10.arr[High(arr)] := StringOfChar(Char(i + 1), 3);11.end;12.for s in arr do ShowMessage(s);13.end;14.15.procedure TForm1.Button2Click(Sender: TObject);16.var17.arr: TArray<string>;18.i: Integer;19.s: string;20.begin21.for i := 0 to 23 do22.begin23.SetLength(arr, Length(arr)+1);24.arr[High(arr)] := StringOfChar(Char(i + 1), 3);25.end;26.for s in arr do ShowMessage(s);27.end;（五）在 initialization 中建立、在 finalization 中释放[delphi] view plaincopyprint?1.type2.TForm1 = class(TForm)3.Button1: TButton;4.procedure Button1Click(Sender: TObject);5.end;6.7.var8.Form1: TForm1;9.10.implementation11.12.{$R *.dfm}13.14.var15.List: TStringList;16.17.procedure TForm1.Button1Click(Sender: TObject);18.begin19.List.Clear;20.List.Add('WanYi');21.ShowMessage(List.Text);22.end;23.24.initialization25.List := TStringList.Create;26.finalization27.List.Free;28.29.end.（六）使用记录（现在的记录支持使用方法）[delphi] view plaincopyprint?1.type2.TForm1 = class(TForm)3.Button1: TButton;4.procedure Button1Click(Sender: TObject);5.end;6.7.//8.TBase = record9.private10.FName: string;11.procedure SetName(const AName: string);12.public13.constructor Create(const AName: string);14.property Name: string read FName write SetName;15.end;16.17.var18.Form1: TForm1;19.20.implementation21.22.{$R *.dfm}23.24.procedure TForm1.Button1Click(Sender: TObject);25.var26.X: TBase;27.begin28.X := TBase.Create('Test');29.ShowMessage(); := 'Test1';31.ShowMessage();32.{X 在此自动释放}33.end;34.35.{ TBase }36.37.constructor TBase.Create(const AName: string);38.begin39.FName := AName;40.end;41.42.procedure TBase.SetName(const AName: string);43.begin44.FName := AName;45.end;46.47.end.（七）使用接口[delphi] view plaincopyprint?1.type2.TForm1 = class(TForm)3.Button1: TButton;4.procedure Button1Click(Sender: TObject);5.end;6.7.//8.IBase = Interface9.function GetName: string;10.procedure SetName(const AName: string);11.property Name: string read GetName write SetName;12.end;13.14.//15.TBase = class(TInterfacedObject, IBase)16.private17.FName: string;18.protected19.function GetName: string;20.procedure SetName(const AName: string);21.public22.constructor Create(const AName: string);23.end;24.25.var26.Form1: TForm1;27.28.implementation29.30.{$R *.dfm}31.32.procedure TForm1.Button1Click(Sender: TObject);33.var34.X: IBase;35.begin36.X := TBase.Create('Test');37.ShowMessage(); := 'Test1;39.ShowMessage();40.{X 在此自动释放}41.end;42.43.{ TBase }44.45.constructor TBase.Create(const AName: string);46.begin47.FName := AName;48.end;49.50.function TBase.GetName: string;51.begin52.Result := FName;53.end;54.55.procedure TBase.SetName(const AName: string);56.begin57.FName := AName;58.end;59.60.end.。

Delphi常见错误代码

Delphi常见错误代码及中文解释';' not allowed before 'ELSE' ElSE前不允许有“;”'<clause>' clause not allowed in OLE automation section 在OLE自动区段不允许“<clause>”子句'<name>' is not a type identifier <name>不是类型标识符'<name>' not previously declared as a PROPERTY <name>前面没有说明PROPERTY'GOTO <label>' leads into or out of TRY statement GOTO <label>进入或超出TRY语句的范围<clause1> clause expected, but <clause2> found 要求子句<clause1>，但出现<clause2>16-Bit fixup encountered in object file '<text>' 在对象文件<text>遇到16位修复486/487 instructions not enabled 不能用486/487指令Abstract methods must be virtual or dynamic 抽象方法必须为虚拟的或动态的Array type required 需要数组类型Assignment to FOR-Loop variable '<Name>' 给FOR循环变量<Name>赋值Bad argument type in variable type array constructor 在变量类型数组结构中不正确的参数类型Bad file format '<name>' 错误的文件格式<name>Bad file format: <Filename> 错误的文件格式<Filename> Bad global symbol definition: '<Name>' in object file '<Filename>' 对象文件'<Filename>'中错误的全局符号定义'<Name>'Bad unit format: <Filename> 错误的单元格式<Filename> BREAK or CONTINUE outside of loop BREAK或CONTINUE超出循环Cannot add or subtract relocatable symbols 不能增加或减少可重置的符号Cannot assign to a read-only property 不能指定只读属性Cannot BREAK, CONTINUE or EXIT out of a FINALLY clause 超出FINALLY 子句的范围，不能使用BREAK,CONTINUE或EXIT语句Cannot initialize local variables 不能初始化局部变量Cannot initialize multiple variables 不能初始化多个变量Cannot initialize thread local variables 不能初始化线程局部变量Cannot override a static method 不能覆盖静态方法Cannot read a write-only property 不能读取只写属性Case label outside of range of case expression CASE标号超出了CASE 表达式的范围Circular unit reference to <Unitname> 对单元<Unitname>循环引用Class already has a default property 类已具有默认的属性Class does not have a default property 类没有默认的属性Class or object types only allowed in type section 在类型区段只允许有类或对象类型Class type required 需要类类型Close error on <Filename> 文件<Filename>关闭错误Compile terminated by user 用户中止编译Constant expected 要求常量Constant expression expected 要求常量表达式Constant expression violates subrange bounds 常量表达式超出子界范围Constant object cannot be passed as var parameter 常量对象不能作为变量参数传递Constant or type identifier expected 要求常量或类型标识符Constants cannot be used as open array arguments 常量不能用作打开数组参数Constructing instance of '<name>' containing abstract methods 构造的<name>实体包含抽象的方法Could not compile used unit '<Unitname>' 不能用单元<Unitname>编译Could not create output file <Filename> 不能建立输出文件<Filename>Could not load RLINK32.DLL 不能加载RLINK32.DLLData type too large: exceeds 2 GB 数据类型太大：超过2GB Declaration of <Name> differs from previous declaration <Name>的说明与先前的说明不同Default property must be an array property 默认的属性必须为数组属性Default values must be of ordinal, pointer or small set type 默认的值必须为序数、指针或小集类型Destination cannot be assigned to 目标不能指定Destination is inaccessible 目标不能存取Dispid '<number>' already used by '<name>' DISPID标识号已被<name>使用Dispid clause only allowed in OLE automation section DISPID子句只能在OLE自动区段中使用Division by zero 除数为零Duplicate case label CASE标号重复Duplicate tag value 重复的标志值Dynamic method or message handler not allowed here 这里不允许有动态方法或信息处理程序Dynamic methods and message handlers not allowed in OLE automation section在OLE 自动区段不允许有动态方法或消息处理程序Element 0 inaccessible - use 'Length' or 'SetLength' 元素0不能存取-使用LENGTH或SETLENGTHError in numeric constant 数值常量错误EXCEPT or FINALLY expected 要求EXCEPT或FINALLY EXPORTS allowed only at global scope EXPORTS只允许在全局范围使用Expression has no value 表达式没有值Expression too complicated 表达式太复杂Field definition not allowed in OLE automation section 在OLE自动区段中不允许域定义Field definition not allowed after methods or properties 在方法或属性后不允许域定义Field or method identifier expected 要求域或方法标识符File not found: <Filename> 文件<Filename>没有找到File type not allowed here 这儿不允许文件类型For loop control variable must be simple local variable FOR循环控制变量必须为简单局部变量For loop control variable must have ordinal type FOR循环控制变量必须为序数类型FOR or WHILE loop executes zero times - deleted FOR或WHILE循环执行零次-删除FOR-Loop variable '<name>' cannot be passed as var parameter FOR循环变量<name>不能作为参数传递FOR-Loop variable '<Name>' may be undefined after loop 在循环后的FOR循环变量<NAME>是不确定的Function needs result type 函数需要结果类型Identifier redeclared: '<name>' 标识符<name>重复说明Illegal character in input file: '<char>' ($<hex>) 在输入文件中的非法字符'<char>'Illegal message method index 非法的消息方法指针Illegal reference to symbol '<Name>' in object file '<Filename>' 在对象文件<filename>中对符号<name>的非法引用Illegal type in OLE automation section: '<typename>' 在OLE自动区段中的非法类型<typename>Illegal type in Read/Readln statement 在Read/Readln语句中的非法类型Illegal type in Write/Writeln statement 在Write/Writeln语句中的非法类型Inaccessible value 不可存取的值Incompatible types: '<name>' and '<name>' 不兼容的类型<name>和<name>Incompatible types: <text> 不兼容的类型<text>Inline assembler stack overflow 内联汇编溢出Inline assembler syntax error 内联汇编语法错误Instance variable '<name>' inaccessible here 实体变量<name>在这里不能存取Integer constant or variable name expected 要求整形常量或变量名Integer constant too large 整型常量太大Internal error: <ErrorCode> 内部错误<errorcode>Invalid combination of opcode and operands 操作码与操作对象的无效组合Invalid compiler directive: '<Directive>' 无效的编译指令<DIRECTIVE> Invalid function result type 无效的函数值类型Invalid message parameter list 无效的消息参数列表Invalid register combination 无效的寄存器组合Invalid typecast 无效的TYPECASELabel '<Name>' is not declared in current procedure 在当前的过程中没有说明标号<NAME>Label already defined: '<Labelname>' 标号<LABELNAME>已经定义Label declaration not allowed in interface part 在界面部分不允许标号说明Label declared and referenced, but not set: '<label>' 标号被<label>说明及引用,但不能设置Label expected 要求标号Left side cannot be assigned to 左边不能赋值Line too long (more than 255 characters) 行太长(超出255个字符) Local class or object types not allowed 不允许局部的类或对象类型Local procedure/function '<Name>' assigned to procedure variable 局部过程/函数<NAME>赋给过程变量LOOP/JCXZ distance out of range LOOP/JCXZ距离超出范围Low bound exceeds high bound 下界超过上界Memory reference expected 要求内存引用Method '<name>' hides virtual method of base type '<name>' 方法<NAME>隐藏了基类型为<NAME>的虚拟方法Method '<name>' not found in base class 在基类中没有找到方法<NAME>Method identifier expected 要求方法标识符Missing ENDIF directive 缺少ENDIF指令Missing operator or semicolon 缺少操作符或分号Missing or invalid conditional symbol in '$<symbol>' directive 在$<symbol>指令中缺少或无效的条件符号Missing parameter type 缺少参数类型Necessary library helper function was eliminated by linker 必要的库帮助函数被连接程序删除No definition for abstract method '<name>' allowed 抽象方法<NAME>没有定义Not enough actual parameters 没有足够的实际参数Number of elements differs from declaration 元素数与说明不同Numeric overflow 数值溢出Object or class type required 需要对象或类类型Object type required 需要对象类型Only register calling convention allowed in OLE automation section 在OLE自动区段中只允许寄存器调用约定Operand size mismatch 运算对象大小匹配Operator not applicable to this operand type 运算符不使用于这一运算对象类型Order of fields in record constant differs from declaration 在记录常量中的域次序与说明不同Ordinal type required 需要序数类型Out of memory 内存溢出Overflow in conversion or arithmetic operation 转换或算术操作溢出Overriding automated virtual method '<name>' cannot specify a dispid 覆盖的自动虚拟方法<NAME>不能指定DISPIDPACKED not allowed here 这里不允许PACKED Pointer type required 需要指针类型Procedure cannot have a result type 过程不能有结果类型Procedure DISPOSE needs destructor 过程DISPOSE需要destructorProcedure FAIL only allowed in constructor 过程FAIL只允许在constructor方法中Procedure NEW needs constructor 过程NEW需要constructor 方法PROCEDURE or FUNCTION expected 要求PROCEDURE或FUNCTIONProcedure or function name expected 要求过程或函数名Program or unit '<name>' recursively uses itself 程序或单元递归Property '<name>' does not exist in base class 在基类中<NAME>属性不存在Published property '<name>' cannot be of type <type> Published属性<NAME>不能具有类型<type>Published Real48 property '<name>' must be Single, Double or Extended Published REAL属性<NAME>必须为Single, Double或ExtendedRe-raising an exception only allowed in exception handler 在意外处理中只允许重新引起意外处理Read error on <Filename> 文件<FILENAME>读出错Record, object or class type required 需要记录,对象或类类型Redeclaration of '<name>' hides a member in the base class <NAME>的重新说明隐藏了基类中一个元素Redeclaration of property not allowed in OLE automation section 在OLE自动区段中不允许属性重复说明Return value of function '<Functionname>' might be undefined 函数<Functionname>的返回值可能没有定义Seek error on <Filename> 在<FILENAME>中搜索错误Segment/Offset pairs not supported in Borland 32-bit Pascal 在Borland 32位的PASCAL中不支持Segment/Offset对Sets may have at most 256 elements 集至少有256个元素Size of published set '<name>' is >32 bits published集<NAME>的大小大于32字节Slice standard function only allowed as open array argument Slice标准函数只允许作为打开数组参数Statement expected, but expression of type '<type>' found 要求语句,但出现类型<TYPE>的表达式Statements not allowed in interface part 在界面中不允许的语句String constant too long 字符串常量太长String constant truncated to fit STRING[<number>] 字符串常量截取到适合STRING[<number>]Strings may have at most 255 elements 字符串至少255个元素Structure field identifier expected 要求结构域标识符Syntax error in real number 实数语法错误System unit out of date or corrupted: missing '<name>' 系统单元超出日期或损坏:缺少<NAME>Text after final 'END. 编译器忽略END.后的文本This form of method call only allowed for class methods 该方法的窗体只允许类方法This form of method call only allowed in methods of derived types 该方法的窗体只允许在导出类型的方法中This type cannot be initialized 这一类型不能初始化Thread local variables cannot be ABSOLUTE 线程局部变量不能是ABSOLUTEThread local variables cannot be local to a function or procedure 线程局部变量对函数不能是局部的Too many actual parameters 太多的实际参数Too many conditional symbols 太多的条件符号Type '<name>' has no type info 类型<NAME>没有类型信息Type '<Name>' is not yet completely defined 类型<NAME>至今没有定义Type '<name>' must be a class to have a PUBLISHED section 类型<NAME>必须是在PUBLISHED区段中的类Type '<name>' must be a class to have OLE automation 类型<NAME>必须是具有OLE自动的类Type '<name>' needs finalization - not allowed in file type 类型<NAME>需要初始化-不允许在文件类型中Type '<name>' needs finalization - not allowed in variant record 类型<NAME>需要初始化-不允许在变体记录Type expected 要求TYPEType not allowed in OLE Automation call 在OLE自动调用中不允许的类型Type of expression must be BOOLEAN 表达式的类型必须为BOOLEAN型Type of expression must be INTEGER 表达式的类型必须为INTEGER型TYPEINFO standard function expects a type identifier TYPEINFO标准函数要求类型标识符TYPEOF can only be applied to object types with a VMT TYPEOF只能用于具有VMT的对象类型Types of actual and formal var parameters must be identical 形参与实参必须一致Undeclared identifier: '<name>' 未说明的标识符<NAME> Unexpected end of file in comment started on line <Number> 以行<Number>开始的注释中出现不应有的文件结束Unit <Unit1> was compiled with a different version of <Unit2> 单元<UNIT1>与不同版本的<UNIT2>编译Unit name mismatch: '<Unitname>' 单元名不匹配<UNITNAME> Unknown directive: '<Directive>' 未知的指令<DIRECTIVE> Unnamed arguments must precede named arguments in OLE Automation call 在OLE自动调用中未命名的参数必须在命名的参数前Unsatisfied forward or external declaration: '<Procedurename>' 不满足的向前或外部说明<Procedurename>Unterminated string 未结束的字符串Value assigned to '<Name>' never used 赋给<NAME>的值从未使用过Variable '<name>' inaccessible here due to optimization 由于优化,变量名<NAME>在这里不能存取Variable '<name>' is declared but never used in '<name>' 变量名<NAME>已说明,但不曾使用Variable '<Name>' might not have been initialized 变量名<NAME>可能没有初始化Variable required 需要变量Virtual constructors are not allowed 不允许虚拟的constructors方法Write error on <Filename> 文件<Filename>写错误Wrong or corrupted version of RLINK32.DLL RLINK32.DLL版本错误或不能用*********************************************************************************************** ******************************** 运行错误信息** 运行时出现的错误信息形式为: ** Run-time error nnn at xxxx ** 其中nnn 是运行时的错误编号** xxxx 是运行时的错误地址********************************运行时的错误分为以下三类:* I/O错误:错误编号为100-149编号说明---------------------------------------------------------100 磁盘读错误,若要对超过格式文件尾进行读取时101 磁盘写错误,若磁盘满时,由CloseFile,Write,Writeln或Flush报告102 没有指定文件,若文件变量没有由Assign或AssignFile赋值,由Reset,Rewrite,Append,Rename和Erase报告103 文件没有打开,若文件未打开,由CloseFile,Read,Write,Seek,Eof,FilePos,FileSize,Flush,BlockRead或BlockWrite报告104 输入文件未打开,由Read,Readln,Eof,Eoln,SeekEof或SeekEoln报告有关输入的文本文件未打开105 输出文件未打开,由Write和Writeln报告有关文本文件没有用Console应用程序生成106 无效的数据格式,由Read或Readln报告从文本文件读取的数据格式不正确* 致命错误:错误编号为200-255编号说明---------------------------------------------------------200 被零除201 范围检查错误202 栈上溢203 栈上溢错误204 无效的指针操作205 浮点上溢206 浮点下溢207 无效的浮点操作215 算术上溢错误216 存取非法217 控制-C218 授权指令219 无效的TYPECAST220 无效的变体TYPECAST221 无效的变体操作222 没有变体方法调用DISPATCHER223 不能建立变体数组224 变体不包含数组225 变体数组边界错误226 TLS初始化错误* 操作系统错误编号说明---------------------------------------------------------1899L 不能生成端点映射数据库1752L 不能执行操作1751L 入口点非法1753L 端点映射中没有更多可用的端点5L 存取非法1331L 帐号当前不能用,因此不能登录1793L 用户帐号过期1327L 用户名是有效的,但一些限制不能验明用户57L 网络适配器硬件错误1379L 指定的别名已存在1344L 分配用于更新的内存块不足85L 本地设备名已在使用183L 试图建立已存在的文件1074L 系统当前正以最新最好的配置运行7L 存储控制块被破坏534L 运算结果超出32位174L 文件系统不支持锁定类型的原子变化199L 操作系统不能运行这一程序160L 传递给DosExecPgm的参数串不正确22L 设备不能识别的命令1361L 安全描述符不在要求的格式66L 网络资源类型不正确1200L 指定的设备名无效119L 系统不支持请求的命令10L 环境不正确193L %1不是有效的基于Windows的应用程序11L 企图装载不正确格式的程序1346L 指定的模拟级无效或没有提供要求的模拟级1340L 试图建立继承的ACL或没有继承的ACE 24L 程序指定的命令长度不正确1365L 登录段与要求的操作状态不一致67L 网络名找不到58L 指定的服务器不能执行请求的命令53L 网络路径没有找到161L 指定的路径名无效230L 管道状态无效1206L 网络连接协议被损坏1204L 指定的网络提供者名无效60L 远程适配器不兼容159L 线程ID地址不正确1349L 符号对象类型不当20L 系统不能找到指定的设备2202L 指定的用户名无效1348L 请求的确定信息类是无效的1009L 配置记录数据库被破坏1010L 配置记录密钥无效1102L 遇到磁带头或分区1076L 当前引导已接受为最新的控制设置109L 管道结束111L 文件名太长1111L I/O总线重新设置170L 请求的资源在使用142L 此时系统不能执行JOIN或SUBST120L 输入的API只能在Windows/NT模式下工作1003L 由于一些原因不能完成的功能173L 锁定请求对提供撤消区未解决266L 不能使用1407L 不能找到Windows类1368L 表示要试图通过命名管道的模拟还没有读取82L 不能生成目录或文件1205L 不能打开网络连接协议1351L 没有联系的域控制器或在域内对象被保护,因此不能存取必要信息1310L 委托组不能禁止1347L 试图打开匿名的符号,匿名级的符号不能打开1011L 配置记录密钥不能打开1012L 配置记录密钥不能读取1013L 配置记录密钥不能写1021L 试图在易变的父关键字下建立稳定的子关键字129L 应用程序%1不能在Windows模式下运行1436L 子窗口不能有菜单1059L 指定子循环服务从属1410L 类已存在1411L 类不存在1412L 类仍在打开的窗口中1418L 线程没有打开的剪切板1201L 设备当前没有连接,但要记住连接1421L 没有找到控制ID1121L 由于超时已到,一系列的I/O操作完成23L 数据错误16L 目录不能删除1065L 指定的数据库不存在1425L 传递给ReleaseDC的无效HDC1051L 终止控制已送到其他独立运行服务的服务中1435L 不能破坏其他线程产生的对象55L 指定的网络资源不再有效1202L 试图记住先前记住的设备2404L 设备由激活的进程在使用,不能断开连接1107L 当装载磁带时,找不到磁带的分区信息145L 目录非空144L 目录不是根目录的子目录130L 试图使用文件句柄来打开磁盘操作267L 目录名无效157L 段已丢失,不能锁定107L 由于没有插入交换磁盘,程序终止1393L 磁盘结构损坏,不能在读取112L 磁盘上没有足够的空间1127L 即使重试,存取硬盘也失败1126L 在存取硬盘时,即使重试,存取校准操作也失败1128L 即使磁盘控制器重新设置,存取硬盘也失败1114L DLL初始化例程失败1356L 指定的域已存在1357L 在该版本中试图超出每个服务器域的限制1810L 指定域的名字或安全ID与该域的受托信息不一致108L 磁盘在使用或被其他进程锁定1221L 工作族或域名已被网络上的其他计算机使用52L 网络上存在重名1078L 名字已在作服务器名或服务显示名使用196L 操作系统不能运行这一应用程序994L 对EA的存取非法276L 在安装文件系统上的EA文件被损坏255L EA不一致277L 在安装文件系统的EA文件上的EA表用完275L EA不适合在缓冲区中282L 安装文件系统不支持扩展属性1100L 在操作中出现磁带尾部标志203L 系统不能找到输入的环境选项1129L 遇到磁带的物理尾部1501L 没有打开的日志文件事件,因此事件登录服务没有启动1503L 在读取之间事件日志文件已改变1500L Eventlog登录文件之一破坏1064L 在处理控制请求时出现意外101L 专门信号被其他进程所拥有192L 操作系统不能运行%11208L 出现扩展错误83L INT24失败1063L 服务进程不能连接到服务控制器1392L 文件或目录被损坏,不能在读取80L 文件存在1006L 文件卷已变化,因此打开的文件不再有效2L 系统不能找到指定的文件1101L 磁带存取达到文件标志206L 文件名或后缀太长1125L 软盘控制器返回与登记不一致的结果1122L 在软盘上没有找到ID地址标志1123L 软盘扇区ID域与软盘控制器道地址不匹配1124L 软盘控制器报告出现不能由软驱识别的错误1007L 请求的操作在全屏幕模式不能执行31L 连接到系统上的设备不正常1360L 通配存取类型包含在存取屏蔽中1429L 该异常分支只能为全局设置1318L 指定的组已存在39L 磁盘满38L 到达文件末1428L 没有模块处理,不能设置非局部的异常处理1431L 异常分支没有安装1409L 热键已登记1419L 热键没有登记1441L 所有的DeferWindowsPosHWND必须具有相同的父1324L 在更新口令时,该返回状态表示新口令中包含不允许的值202L 操作系统不能运行%1122L 传递给系统调用的数据区太小1358L 由于灾难性的介质错误或磁盘数据结构破坏引起请求的操作不能完成1383L LSA数据库内部不一致1359L SAM遇到内部数据库不一致的错误,可防止SAM的进一步操作1800L 指定的优先级无效1448L 滚动条范围大于0x7FFF1338L 安全描述符结构无效198L 操作系统不能运行%1180L 系统检测到不正确的段号1799L 指定的分隔符文件无效1352L SAM服务器状态错误,不能完成期望的操作1057L 帐号名无效或不存在1052L 对该服务请求的控制无效1071L 指定的服务数据锁定无效1213L 指定的服务名格式无效1215L 指定的共享名格式不正确1449L SHOWWINDOWS命令无效1337L SID结构无效209L 公布的信号不正确1439L 参数无效189L 操作系统不能运行%1188L 操作系统不能运行%11335L 子权限值无效114L 目标内部文件标识符不正确1444L 线程ID无效1784L 提供的用户缓冲区对请求操作失效118L 写后验证开关参数值不正确1400L 窗口处理无效1329L 用户帐号限制,不能从源工作站登录1117L 由于I/O设备错误,请求不能完成996L 重叠的IO时间不在发信号状态997L 重叠的IO操作在处理中197L 操作系统当前不能配置来运行应用程序1119L 不能打开与其它设备共享IRQ的设备,至少有一使用该IRQ的其他设备已打开147L 没有足够的可用资源来处理这一命令133L 由于驱动器已包含连接,JOIN或SUBST命令不能使用134L 试图在已连接的驱动器上使用JOIN或SUBST命令146L 指定的路径正在用替换149L 试图替代先前已替代的驱动器目录135L 试图在已替代的驱动器上使用JOIN或SUBST命令194L 操作系统不能运行%1138L 系统试图替代已替代的目录140L 系统试图替代已替代的目录1430L 日常异常处理已安装1018L 在有删除标志的登记键上非法操作1020L 试图在已有子键或值的登记键建立符号连接154L 输入的卷标超过11个字符的限制,前11个字符写在磁盘上,其余字符自动删除1322L 请求的操作被禁止或删除最新的其余管理员帐号1434L 该列表框不支持制表符1416L 列表符ID没有找到1390L 试图修改用户口令,但没有提供要求的LM口令1303L 联接局部RPC,要求用户话路密钥167L 试图锁定文件失败的区域33L 由于其他进程已锁定部分文件,该文件不能被进程存取212L 端锁定,因此不能重新分配1502L 事件登录文件已满1326L 由于用户名或验证信息不正确,试图登录无效1380L 请求登录的类型(如网络,服务等)没有被目标系统授权1366L 登录话路ID已在使用1363L 试图启动新的话路管理程序或用已在使用的LSA登录话路1385L 请求登录的类型(如网络,服务等)没有授权1334L 没有更多可分配的LUID164L 在系统中不能生成更多的线程1110L 驱动器中的介质已改变1378L 指定的帐号名不是别名的成员1320L 指定的用户帐号已在指定的组帐号中或由于组中有成员,不能删除1377L 指定的帐号名不是别名的成员1321L 指定的用户帐号不是指定组帐号的成员1374L 由于组是基本组,因此成员不能从该组中删除208L 取决文件名符号*或?输入不正确或指定的全局文件符号更多126L 不能找到指定的模块234L 需要更多的数据1120L 一系列的I/O操作被其他写到串口的操作完成317L 系统不能找到消息号为0x%1的消息131L 试图在超出文件头的位置移动文件指针215L 不能嵌套调用LoadModule1792L 试图登录,但网络登录服务没有启动88L 网络写失败64L 指定的网络名不再有效65L 网络存取非法54L 网络在忙6118L 该工作组的服务器列表当前不可用232L 管道在进程中关闭1104L 在磁带存取中,到达数据标志尾部1309L 试图由当前不在模拟客户的线程上操作模拟符号1391L ACL不包含可继承的组件1019L 系统不能分配记录文件要求的空间1807L 使用的帐号在内域受托帐号中,使用正常的帐号或远程用户帐号来存取该服务器1809L 使用的帐号在服务器受托帐号中,使用正常的帐号或远程用户帐号来存取该服务器1311L 当前没有可用的登录服务器来服务登录请求1808L 使用的帐号在工作站受托帐号中,使用正常的帐号或远程用户帐号来存取该服务器1112L 由于驱动器中没有介质,磁带查询失败18L 没有更多的文件259L 没有更多的可用数据113L 没有更多的可用内部文件标识符1203L 没有网络提供者接收给定的路径2138L 没有网络或网络未启动89L 此时系统不能启动另一进程1302L 对该帐号没有指定限额1447L 窗口不能有滚动条1350L 试图对没有安全性的对象操作1116L 由于没有关机在处理中,试图放弃关机失败205L 在命令子树中没有进程有信号句柄62L 在服务器上存储等待打印文件的空间不足1376L 指定的别名不存在1355L 指定的域不存在1319L 指定的组不存在1312L 指定的登录话路不存在,可能已终止1387L 不存在的新成员不能添加到别名中1364L 指定的验证包未知1313L 指定的特权不存在1317L 指定的用户不存在1437L 窗口不能具有系统菜单1008L 试图引用不存在的符号1786L 工作站没有受托秘密1787L 域控制器对该工作站没有帐号1113L 对目标多字节代码页存在的Unicode字符没有映射1394L 对指定的登录话路没有用户话路密钥125L 磁盘没有卷标1417L 没有找到通配符998L 对内存位置的无效存取1445L 用非MDI子窗口调用DefMDIChildProc1332L 映射的信息没有转变1300L 不是所有权限赋给调用者1442L 窗口不是子窗口2250L 网络连接不存在1207L 不能枚举非容器26L 指定的磁盘不能存取8L 没有足够的空间处理该命令1130L 没有足够的空间处理该命令服务器136L 系统试图删除没有连接的驱动器158L 段已锁定1362L 请求的动作只受登录进程的限制,调用进程没有登记为登录进程288L 试图释放不被调用者拥有的互斥法21L 驱动器没有准备好1017L 系统试图装载或恢复文件到登记中,但指定的文件格式不正确17L 系统不能将文件移动到不同的驱动器上137L 系统试图删除没有替代的驱动器50L 不支持网络请求1022L 改变请求正在完成,信息没有返回在调用者的缓冲区.调用者现在需要模拟文件,以找到所做的修改1386L 没有提供必要的NT交叉保密口令而试图以安全帐号管理员改变用户口令1304L WindowsNT的口令太复杂,无法将其转换为Windows的网络口令(该口令返回NULL字符串)110L 系统不能打开指定的设备或文件2401L 有打开文件或请求在连接期995L 由于线程退出或应用程序请求,I/O操作放弃28L 打印机没有纸84L 处理该请求没有足够的空间14L 处理该操作没有足够的空间1105L 磁带没有分区1330L 用户帐号的口令已到期1325L 在更新口令,该状态表示违反一些口令更新规则148L 指定的路径现在不能用3L 系统不能找到指定的路径231L 所有的管道实体在忙535L 在管道的另一端有进程536L 等待进程打开管道的另一端233L 在管道的另一端没有进程1446L 下拉式菜单已激活1131L 已检测到潜在的僵局条件63L 要打印的等待文件被删除1802L 打印机已存在1795L 指定的打印驱动程序已安装61L 打印队列已满。

Delphi

delphi百科名片Delphi，是Windows平台下著名的快速应用程序开发工具(Rapid Application Developme nt，简称RAD)。

它的前身，即是DOS时代盛行一时的“BorlandTurbo Pascal”，最早的版本由美国Borland（宝兰）公司于1995年开发。

主创者为Anders Hejlsberg。

经过数年的发展，此产品也转移至Embarcadero公司旗下。

Delphi是一个集成开发环境（IDE），使用的核心是由传统Pascal语言发展而来的Object Pascal，以图形用户界面为开发环境，透过IDE、VCL工具与编译器，配合连结数据库的功能，构成一个以面向对象程序设计为中心的应用程序开发工具。

概述在古希腊神话里，DELPHI是智慧女神，米开朗基罗在意大利有著名的DELPHI 雕像。

由Borland公司推出的Delphi是全新的可视化编程环境，为我们提供了一种方便、快捷的Windows应用程序开发工具。

它使用了Microsoft Windows图形用户界面的许多先进特性和设计思想，采用了弹性可重复利用的完整的面向对象程序语言(Object-Oriented Language)、当今世界上最快的编译器、最为领先的数据库技术。

对于广大的程序开发人员来讲，使用Delphi开发应用软件，无疑会大大地提高编程效率，而且随着应用的深入，您将会发现编程不再是枯燥无味的工作——Delphi的每一个设计细节，都将带给您一份欣喜。

Delphi是Borland公司研制的新一代可视化开发工具，可在Windows3.x、Wind ows95、WindowsNT、WindowsXP、Windows Vista等环境下使用。

当前，DELPH I 也可以在LINUX平台上开发应用，其在LINUX上的对应产品Kylix。

DELPHI 拥有一个可视化的集成开发环境(IDE)，采用面向对象的编程语言Obje ctPascal和基于部件的开发结构框架。

delphi从不入门到入门

20
第一章delphi编程基础
例如： i := 0; while i<10 do begin i := i+1; writeln(i); end;
21
第一章delphi编程基础
3. for语句 for语句的程序代码会执行一定的次数。它需要一个循环变量来控制循环次数。您需要说明一个变量，它的类型可以是整形、布尔型、字符型、枚举型或子界型。
9
第一章delphi编程基础
• 象变量一样，常量也有类型。不同的是，常量假设其类型就是常量说明中其所代表的值的类型。上文的三个常量的类型分别是real型、整型、字符串型。常量用“= " 表示两边的值是相等的。
10
第一章delphi编程基础
• 过程和函数过程： procedure DealCoverageYear(AValue:string;var tpy_CoveragePeriod:string;) begin if Pos('年',AValue)>0 then tpy_CoveragePeriod :='0'; else if Pos('岁',AValue)>0 then tpy_CoveragePeriod :='1'; end;
26
第一章delphi编程基础
在枚举型中，括号中的每一个值都有一个由说明它的位置决定的整形值。例如Sunday有整形值 0，Monday有整形值1等。您可以把 DayOfWeek说明为一个整形变量，并将一星期的每一天赋一个整形值以达到相同的效果，但用枚举型会使得程序可读性好，编写容易。当您在枚举型中列出值时，您同时说明了这个值是一个标识符。例如您的程序中如果已经含有 TDays类型且说明了DayOfWeeks变量，则程序中便不能使用Monday变量，因为它已经被说明为标识符了。 27

Delphi简介专题知识讲座

一种原则旳单元文件格式如下： unit Unit1; //单元头
interface uses {单元列表} {接口部分}
implementation uses {单元列表} {实现部分}
initialization {初始化部分}
finalization {结束部分}
end.
项目文件窗体文件单元文件
一、项目和项目文件
开发应用程序旳全部有关文件都组织在一种项目中，Delphi项目中包括旳文件诸多，大部分是由Delphi自动创建并维护旳。我们只需要关注项目文件、窗体文件和单元文件。
每一种Delphi应用程序都有一种扩展名为dpr旳项目文件，是由Delphi自动建立并维护旳，一般情况下不必修改它旳内容。
类产品中最强旳
二、Delphi7旳开启与退出
开启Delphi7 选择【开始】 → 【程序】 → 【 Borland
Delphi 7】→【Delphi 7】命令。退出Delphi7 选择【File】→【Exit】命令。
1.2 Delphi7集成开发环境
主窗口对象浏览器对象树状列表窗体设计器代码编辑器
当程序中具有多种窗口时，会有多种单元出目前代码编辑器中。单击单元页标签，能够实现多种单元之间旳切换。
六、一种简朴旳程序
Delphi应用程序旳一般环节：设计程序旳顾客界面
选择组件→放置组件→排列组件→设置组件旳属性添加代码编译运营程序保存文件
1.3 Delphi程序旳基本构造
Delphi程序设计与应用教程
宁正元主编刘雄恩陈琼副主编
中国水利水电出版社
本章学习要点了解Delphi旳特征；熟悉Delphi集成开发环境（IDE）了解编制Delphi应用程序旳一般环节；掌握程序项目旳文件构成和类型，以及

2024年度Delphi程序设计实用教程第2版

43
系统架构设计思路
2024/2/2
整体架构设计
设计系统的整体架构，包括客户端、服务器端、数据库等组成部分。
模块划分
将系统划分为多个模块，每个模块负责实现特定的功能，提高系统的可维护性和可扩展性。
接口设计
定义模块之间的接口，包括数据接口、函数接口等，确保模块之间的协同工作。
03
包括基于TCP和UDP的Socket编程，可应用于实时聊天、文件
传输等场景。
34
Web应用开发技术
01
02
03
Web服务器
用于处理客户端请求并返回响应的服务器程序。
2024/2/2
Web开发语言
如HTML、CSS、 JavaScript等，用于构建 Web应用程序的前端界面和交互逻辑。
Web开发框架
5
Delphi开发环境安装与配置
下载并安装Delphi开发环境，选择合适的版本和组件库。
安装和配置数据库连接驱动，以便在 Delphi中访问数据库。
2024/2/2
配置开发环境，包括设置编译器选项、调试器选项、代码编辑器风格等。
6
第一个Delphi程序
创建一个新的Delphi项目，选择适当的项目类型和模板。
构造类型
如数组、记录、集合、文件等复合数据类型。
变体类型
可存储不同类型数据的灵活数据类型。
10
变量与常量
变量声明与赋值
介绍如何在Delphi中声明变量并为其赋值。
2024/2/2
常量定义与使用
讲解常量的概念、定义方法及在程序中的应用。
变量作用域
阐述局部变量、全局变量的概念及其作用范围。
11

DELPHI常见属性说明【二】

DELPHI常见属性说明【⼆】常⽤DELPHI控件属性设置说明⽬录TForm ClassTPanel组件TToolBar ClassTToolButton ClassTTimer ClassTADOConnection ClassTADOQuery ClassTADODataSet ClassTDBGrid ClassTADOStoredProc ClassTButton ClassTBitBtn ClassTComboBox ClassTStaticText ClassTLabel ClassTEdit ClassTGroupBox ClassTRadioGroup ClassTListbox ClassTTreeView ClassTDataModule ClassVC++使⽤串⼝I. Open 16II. ConfigurationIII. ReadIV. WriteV. CloseConclusionLicenseTForm ClassTForm代表⼀个标准的应⽤程序窗⼝。

在设计阶段，当你在窗体设计器内创建窗体时，他们作为窗体类的⼦节点被执⾏。

窗体能代表应⽤程序的主窗⼝，或者对话框，或MDI的children。

⼀个窗体能包含其它对象，如TButton， TCheckBox和TComboBox对象等。

ArrangeIcons：安排最⼩化MDI⼦窗体的图标；Cascade：排列MDI⼦窗体，使他们重叠；Next：激活在窗体队列中的下⼀个⼦窗体；Previous：激活在窗体队列中的前⼀个MDI⼦窗体；Title：排列MDI⼦窗体，使他们都是⼀样的⼤⼩。

Action：指定与控件有关的活动；ActiveControl：指定以窗体为焦点的控件；Align：控件如何停靠在容器（⽗控件）中；AlphaBlend：指定窗体是否透明；AlphaBlendValue：指定⼀个透明窗体的半透明度；Anchors：指定控件如何固定到其⽗控件上；AutoScroll：如果窗⼝不⾜以显⽰它内部的所有控件时，滚动条是否⾃动显⽰在滚动窗⼝控件中；AutoSize：指定控件是否⾃动调节其⼤⼩去容纳⾃⾝内容；BiDiMode：指定控件的双向风格；BorderIcons：指定显⽰在窗体标题栏的图标；BorderStyle：指定窗体边框的外表和⾏为；BorderWidth：指定控件边框的宽度；Caption：指定⽤户辨别控件的⽂本字符串；ClientHeight：指定窗体客户区域的⾼度（像素）；ClientWidth：指定窗体客户区域的宽度（像素）；Clore：指定控件的背景⾊；Constraints：指定控件的尺⼨约束。

2024年delphi程序设计课件

Delphi程序设计课件引言Delphi是一种强大的应用程序开发工具，广泛用于桌面、移动、Web和数据库应用程序的开发。

本课件旨在为初学者提供Delphi程序设计的基础知识和技能，使读者能够掌握Delphi的基本概念和编程技术，从而开发出高效、可靠的应用程序。

第一部分：Delphi简介1.1Delphi的历史和发展Delphi是由Borland公司于1995年推出的，最初的版本是基于ObjectPascal语言的应用程序开发工具。

随着技术的发展，Delphi逐渐扩展支持多种编程语言和平台，如C++、.NET、JavaScript等。

目前，Delphi是由EmbarcaderoTechnologies公司维护和更新的。

1.2Delphi的特点和应用领域Delphi具有丰富的功能和特点，如可视化编程、快速应用程序开发、强大的数据库支持等。

它广泛应用于桌面应用程序、移动应用程序、Web应用程序、数据库应用程序等领域。

第二部分：Delphi编程基础2.1Delphi程序的基本结构Delphi程序由多个单元组成，每个单元包含一个或多个类和过程。

每个Delphi程序至少包含一个主单元，主单元中包含一个主过程，程序的执行从主过程开始。

2.2数据类型和变量Delphi支持多种数据类型，如整数、浮点数、字符、字符串、布尔等。

变量是存储数据值的容器，它们具有数据类型和名称。

在Delphi中，变量必须在声明后才能使用。

2.3控制结构控制结构用于控制程序的执行流程，包括条件语句、循环语句和跳转语句。

条件语句用于根据条件执行不同的代码块，循环语句用于重复执行代码块，跳转语句用于跳转到程序的其他部分。

第三部分：Delphi可视化编程3.1Delphi的可视化编程环境Delphi提供了一个可视化的编程环境，允许开发人员通过拖放控件来创建用户界面。

开发人员可以调整控件的大小和位置，设置控件的属性和事件，从而实现用户界面的设计和功能。

delphi中的按键说明

Delphi中一些常用的组合键值CTRL+A:#1 CTRL+B:#2 CTRL+C:#3 CTRL+D:#4 CTRL+E:#5 CTRL+F:#6 CTRL+G:#7CTRL+H:#8 CTRL+I:#9 CTRL+J:#10 CTRL+K:#11 CTRL+L:#12 CR:#13 CTRL+N:#14CTRL+O:#15 CTRL+P:#16 CTRL+Q:#17 CTRL+R:#18 CTRL+S:#19 CTRL+T:#20CTRL+U:#21 CTRL+V:#22 CTRL+W:#23 CTRL+X:#24 CTRL+Y:#25 CTRL+Z:#26 ESC:#27CTRL+:#28 CTRL+]:#29 SHIFT+CTRL+-:#30 DEL:#127一般用在keydown、keyup、keypress事件中。

OnKeyDown和OnKeyUp事件中的Key是Word型的，表示用户按的是键盘上的哪个键，OnKeyPress中的Key是Char型，表示用户输入什么字符。

一个产生8位(char)常规健值，一个产生16位(word)功能健健值。

1.KeyPress主要用来捕获数字(注意：包括Shift+数字的符号)、字母（注意：包括大小写）、小键盘等除了F1-12、SHIFT、Alt、Ctrl、Insert、Home、PgUp、Delete、End、PgDn、ScrollLock、Pause、NumLock、{菜单键}、{开始键}和方向键外的ANSI字符，KeyDown和KeyUp 通常可以捕获键盘除了PrScrn所有按键(这里不讨论特殊键盘的特殊键）2.KeyPress 只能捕获单个字符KeyDown 和KeyUp 可以捕获组合键。

3.KeyPress 可以捕获单个字符的大小写4.KeyDown和KeyUp 对于单个字符捕获的KeyValue 都是一个值，也就是不能判断单个字符的大小写。

基础语言(Delphi)

End;
精选2021版课件
11
循环结构
Repeat…until语句
Repeat 循环体
Until True 布尔表达式
While…do语句
While True do Begin
循环体 End;
精选2021版课件
12
For…do语句
for循环变量:=初值to（downto）终值 do Begin 循环体语句 End；
型指针.
精选2021版课件
25
注释的使用
在程序中添加注释有助于对程序代码的理解和调试，注释内容一定要简单明确，不要书写过多，只要能够表达代码的功能即可。
注释类型 // {}
(* *)
描述行注释一元注释二元注释
精选2021版课件
26
3.数据的管理
Delphi中常用类来将数据和方法封装起来，从而实现功能的隐匿。使用规范的类，作者可以随时修改类内部的代码，而使用该类的代码却无需作任何修改，这使得代码的维护成了一件轻松的事，大大提高了效率
精选2021版课件
27
什么是类？
从一般意义上讲，类是对具有相似特征和行为事物的一种抽象，即抓住事物的相似性，定义他们的共同性。
从程序设计的角度来讲，类是一种数据类型，严格地说是一种用户定义的数据类型，它有自己的说明和一些操作，它定义了一种由数据成员、属性和方法组成的数据结构。
精选2021版课件
28
类的封装性
类是由封装在一起的数据和方法构成的。所谓封装指的是一个类中的有些成员对其他类来说是不可能直接访问的，这些成员只能由类本身的方法或属性来进行访问。这样做是为了避免由于直接访问数据而造成的错误。

Delphi解释

一、知识点001.Object Pascal中赋值号用:=表示。

002.后缀为.dfm的文件称窗体文件，查看窗体文件的方法：右击窗体-View as Text。

003.后缀为.dpr的文件称项目文件，查看项目文件的方法：Project-View Source。

004.后缀为.pas的文件称单元文件，查看单元文件的方法：双击窗体。

005.{$R *.res} 表示将后缀为.res的文件即资源文件，连接到.exe文件中。

006.Object Pascal字符集，是指在Object Pascal代码中可以使用的符号。

为ASCII字符集。

007.Object Pascal保留字，是指在Object Pascal中预定义的具有特定含义和用途的字符串。

008.标识符，是以字母或下划线开始的字母、数字、下划线序列。

009.在一行中为多个变量声明同一类型的方法是：变量之间，用逗号分隔。

如：x, y, z : Real; 010.Object Pascal中一个代码语句以分号结束。

011.集合类型是一群相同类型元素的组合。

元素可为枚举类型、字符型、布尔型以及它们的子界和整型子界。

012.Object Pascal保留字共有65个。

013.Div运算，只对整数进行运算，除数不能为0，商保留整数。

014.Mod运算，只对整数进行运算，除数不能为0，结果为余数。

015.Delphi语句分为两类：说明语句和可执行语句。

016.xor运算即异或运算，两个操作数的值不同时，结果为true。

017.Delphi语句中的说明语句，如：Type、Var、Const 等，仅在编译期间起作用。

018.Delphi语句中的可执行语句，在运行后依次执行。

0019.Delphi提供了一套强大的对异常情况进行处理的机制。

巧妙地利用，可使程序更为强健。

020.单元全局变量，在单元区的implementation 之后声明，本单元内部有效。

021.VCL通常用于编写Windows应用程序。

Delphi时间函数全集

Delphi时间函数全集function StartOfTheYear(const AValue: TDateTime): TDateTime;function EndOfTheYear(const AValue: TDateTime): TDateTime;function StartOfAYear(const AYear: Word): TDateTime;function EndOfAYear(const AYear: Word): TDateTime;function StartOfTheMonth(const AValue: TDateTime): TDateTime;function EndOfTheMonth(const AValue: TDateTime): TDateTime;function StartOfAMonth(const AYear, AMonth: Word): TDateTime;function EndOfAMonth(const AYear, AMonth: Word): TDateTime;function StartOfTheWeek(const AValue: TDateTime): TDateTime; {ISO 8601}function EndOfTheWeek(const AValue: TDateTime): TDateTime; {ISO 8601}function StartOfAWeek(const AYear, AWeekOfYear: Word; {ISO 8601}const ADayOfWeek: Word = 1): TDateTime;function EndOfAWeek(const AYear, AWeekOfYear: Word; {ISO 8601}const ADayOfWeek: Word = 7): TDateTime;所在单元：Unit DateUtils1、function DateOf(const AValue: TDateTime): TDateTime; 描述使⽤ DateOf 函数⽤来把⼀个 TDateTime 类型的变量转变成⼀个只带有⽇期的 TDateTime 类型变量。

Delphi教程完整版 ppt课件

interface
uses
Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,Dialogs;
type TForm1 = class(TForm) private { Private declarations } public { Public declarations } end;
var Form1: TForm1;
implementation {$R *.dfm} end.
从上述源代码清单中可以看出，窗体对象是从TForm继承下来的。
下面这一行非常重要：
{$R*.dfm}
Pascal语言中的$R指令用于加载一个外部资源文件。*.dfm文件中包含在窗体设计器中创建的表单的二进制代码。其中的“*” 表示与当前单元文件同名的文件。
Delphi7的主菜单包括11个下拉菜单注意：工具栏上的按钮都提供了描述该按钮功能的tooltip，除了组件面板IDE有6个独立的工具栏
IDE工具栏的定制功能并不仅限于配置需要显示的按钮，还可以调整工具栏、组件面板和菜单栏在主窗口中的位置。
Delphi7组件板包含了350多个组件，是 Delphi可视化编程的核心部件，它由27个选项卡组成组件面板如图1-4所示
//单击放大按钮，窗口将放大
begin
form1.Height:=form1.Height+10; //窗口高度10 form1.Width:=form1.Width+10; //窗口宽度10
end;
procedure TForm1.Button2Click(Sender:
TObject); //单击缩小按钮，窗口将缩小

Delphi中的健盘健码对照表

VK_MBUTTON = 4; { NOT contiguous with L & RBUTTON }
{$EXTERNALSYM VK_BACK}
VK_BACK = 8;
{$EXTERNALSYM VK_TAB}
VK_TAB = 9;
{$EXTERNALSYM VK_CLEAR}
VK_CLEAR = 12;
VK_PLAY = 250;
{$EXTERNALSYM VK_ZOOM}
VK_ZOOM = 251;
{$EXTERNALSYM VK_NONAME}
VK_NONAME = 252;
{$EXTERNALSYM VK_PA1}
VK_PA1 = 253;
{$EXTERNALSYM VK_OEM_CLEAR}
{ VK_L & VK_R - left and right Alt, Ctrl and Shift virtual keys.
Used only as parameters to GetAsyncKeyState() and GetKeyState().
No other API or message will distinguish left and right keys in this way. }
VK_F2 = 113;
{$EXTERNALSYM VK_F3}
VK_F3 = 114;
{$EXTERNALSYM VK_F4}
VK_F4 = 115;
{$EXTERNALSYM VK_F5}
VK_F5 = 116;
{$EXTERNALSYM VK_F6}
VK_F6 = 117;
{$EXTERNALSYM VK_F7}