delphi 常量数组_如何在Delphi中声明和初始化常量数组_cumao2792的博客

三个常量数组的示例声明 ( Example Declaration of Three Constant Arrays )

This code example declares and initializes three constant arrays, named Days , CursorMode, and Items .
此代码示例声明并初始化三个名为 Days ， CursorMode 和 Items的 常量数组。
Days is a string array of six elements. Days[1] returns the Mon string.

天是由六个元素组成的字符串数组。 Days [1]返回Mon字符串。
CursorMode is an array of two elements , whereby declaration CursorMode[false] = crHourGlass and CursorMode = crSQLWait. "cr*" constants can be used to change the current screen cursor.

CursorMode 是两个元素组成的数组，其中声明CursorMode [false] = crHourGlass和CursorMode = crSQLWait。 “ cr *”常量可用于更改当前屏幕光标。
Items defines an array of three TShopItem records .

Items 定义了三个TShopItem 记录的数组。
type
TShopItem = record
Name : string;
Price : currency;
end;
const
Days : array[0..6] of string =
(
'Sun', 'Mon', 'Tue', 'Wed',
'Thu', 'Fri', 'Sat'
) ;
CursorMode : array[boolean] of TCursor =
(
crHourGlass, crSQLWait
) ;
Items : array[1..3] of TShopItem =
(
(Name : 'Clock'; Price : 20.99),
(Name : 'Pencil'; Price : 15.75),
(Name : 'Board'; Price : 42.96)
) ;
Trying to assign a value for an item in a constant array raises the "Left side cannot be assigned to" compile time error. For example, the following code does not successfully execute:
尝试为常量数组中的项目分配值会导致“无法分配左侧”的编译时间错误。例如，以下代码无法成功执行：
 Items[1].Name := 'Watch'; //will not compile
  翻译自: https://www.thoughtco.com/declare-and-initialize-constant-arrays-1057596 
 delphi 常量数组 
                    In Delphi, the versatile web-programming language,arrays allow a developer to refer to a series of variables by the same name and to use a number—an index—to tell them apart. 在通用的Web编程语言Delphi中， 数...
1、Delphi提供对常量数组的简单初始化方法如下：
const arrByte: Array[0..2] of byte =(112,32,55);
2、如果想对变量数组进行初始化，可以先声明常量数组，然后，对变量数组进行赋值即可：
procedure AssignArr;
arrMyByte: Array[0..2] of by...
21.2.1   扩展Win32组件外套功能 624
21.2.2   TddgRunButton: 创建属性 631
21.3   TddgButtonEdit：一个容器组件 636
21.3.1   设计 636
21.3.2   显现属性 637
21.3.3   显现事件 637
21.3.4   TddgDigitalClock：创建组件事
             件 639
21.3.5   把窗体加到组件面板上 642
21.4   组件包 644
21.4.1   为什么使用包 644
21.4.2   什么情况下不使用包 645
21.4.3   包的类型 645
21.4.4   包文件 645
21.4.5   在Delphi 5应用程序中使用包 645
21.4.6   把包安装到IDE中 645
21.4.7   设计自己的包 646
21.4.8   包的版本 649
21.4.9   包的编译指令 649
21.4.10   关于{$WEAKPACKAGEUNIT}
               指令 649
21.4.11   包的命名约定 650
21.5   附加包 650
21.6   总结 655
第22章   高级组件技术 656
22.1   伪可视组件 656
22.1.1   扩展提示功能 656
22.1.2   创建一个THintWindow的派生
             类 656
22.1.3   椭圆型的窗口 658
22.1.4   使派生的提示窗口有效 659
22.1.5   放置TDDGHintWindow 659
22.2   动态组件 659
22.2.1   走马灯组件 659
22.2.2   编写这个组件 659
22.2.3   在内存中的位图上输出 659
22.2.4   输出组件 661
22.2.5   使组件动起来 661
22.2.6   测试TddgMarquee组件 668
22.3   编写属性编辑器 670
22.3.1   派生出一个属性编辑器对象 670
22.3.2   把属性当作文本来编辑 671
22.3.3   注册新的属性编辑器 674
22.3.4   用对话框来编辑属性 675
22.4   组件编辑器 677
22.4.1   TComponentEditor 677
22.4.2   一个简单的组件 678
22.4.3   一个简单的组件编辑器 679
22.4.4   注册组件编辑器 679
22.5   对非公开的组件数据进行流操作 681
22.5.1   声明属性 681
22.5.2   DefineProperty()的例子 682
22.5.3   TddgWaveFile：调用Define-
             BinaryProperty()的例子 684
22.6   属性类别 690
22.6.1   类别的类 690
22.6.2   自定义类别 691
22.7   组件列表：TCollection和
       TCollectionItem 694
22.7.1   声明TCollectionItem类：
             TRunBtnItem 695
22.7.2   声明TCollection类：
             TRunButtons 696
22.7.3   实现TddgLaunchPad、TRun-
             BtnItem和TRunButtons 696
22.7.4   用对话框属性编辑器编辑
             TCollectionItem组件的列表 702
22.8   总结 711
第23章   COM和ActiveX 712
23.1   COM基础 712
23.1.1   COM：组件对象模型 712
23.1.2   COM、ActiveX、OLE的异同 713
23.1.3   术语 713
23.1.4   ActiveX的伟大之处 713
23.1.5   OLE 1和OLE 2 713
23.1.6   结构化存储 714
23.1.7   统一数据传输 714
23.1.8   线程模式 714
23.1.9   COM+ 714
23.2   COM与Object Pascal 714
23.2.1   接口 715
23.2.2   使用接口 716
23.2.3   HResult返回类型 719
23.3   COM对象和类工厂 720
23.3.1   TComObject和TComObject-
             Factory 720
23.3.2   in-process COM服务器 721
23.3.3   创建一个in-proc COM服务器实
             例 722
23.3.4   out-of-process COM服务器 723
23.4   聚合 723
23.5   分布式COM 723
23.6   自动化 724
23.6.1   IDispatch接口 724
23.6.2   类型信息 725
23.6.3   后期捆绑与前期捆绑 725
23.6.4   注册 725
23.6.5   创建自动化服务器 725
23.6.6   创建自动化控制器 740
23.7   高级自动化技术 745
23.7.1   自动化事件 745
23.7.2   自动化集合 754
23.7.3   类型库中新的接口类型 760
23.7.4   交换二进制数据 761
23.7.5   COM的语言支持 763
23.8   MTS 766
23.8.1   为什么会出现MTS 767
23.8.2   什么是MTS 767
23.8.3   Delphi中的MTS 770
23.9   TOleContainer 785
23.9.1   一个简单的范例程序 785
23.9.2   一个稍复杂的范例程序 787
23.10   总结 794
第24章   扩展Windows外壳 795
24.1   托盘图标组件 795
24.1.1   API 795
24.1.2   处理消息 797
24.1.3   图标及提示 797
24.1.4   鼠标点击 798
24.1.5   隐藏应用程序 799
24.1.6   托盘图标应用程序举例 805
24.2   应用程序桌面工具栏 807
24.2.1   API 807
24.2.2   TAppBar：AppBar的窗体 808
24.2.3   使用TAppBar 815
24.3   外壳链接 817
24.3.1   获取一个IShellLink实例 818
24.3.2   使用IShellLink 819
24.3.3   创建一个外壳链接 820
24.3.4   获取及设置链接信息 821
24.3.5   一个例子程序 824
24.4   外壳扩展 831
24.4.1   COM对象向导 832
24.4.2   复制钩子处理器 832
24.4.3   上下文菜单处理器 836
24.4.4   图标处理器 844
24.5   总结 850
第25章   创建ActiveX控件 851
25.1   为什么要创建ActiveX控件 851
25.2   创建一个ActiveX控件 851
25.2.1   ActiveX控件向导 852
25.2.2   ActiveX框架 875
25.2.3   属性页 877
25.3   ActiveForm 886
25.4   在Web上的ActiveX 892
25.4.1   与Web浏览器通信 892
25.4.2   Web发布 901
25.5   总结 903
第26章   使用Delphi Open Tools API 904
26.1   Open Tools API接口 904
26.2   使用Open Tools API 905
26.2.1   Dumb向导 905
26.2.2   Wizard向导 908
26.2.3   DDG Search 916
26.3   窗体向导 925
26.4   总结 931
第27章   使用Delphi开发CORBA 932
27.1   ORB 932
27.2   接口 932
27.3   Stub和Skeleton 933
27.4   VisiBroker的ORB 933
27.4.1   VisiBroker的运行时支持服务 933
27.4.2   VisiBroker管理工具 934
27.5   Delphi的CORBA支持 934
27.5.1   CORBA的类支持 935
27.5.2   CORBA对象向导 936
27.5.3   Delphi的类型库编辑器 941
27.6   在Delphi 5中创建CORBA解决方案 942
27.6.1   建立一个CORBA服务器 942
27.6.2   实现IQueryServer的方法 943
27.6.3   编译一个静态绑定的CORBA
             客户 956
27.6.4   编译一个动态绑定的CORBA
             客户 958
27.6.5   跨语言的CORBA 960
27.7   使用VisiBroker ORB 967
27.8   总结 967
第四部分   开发数据库
第28章   编写桌面数据库应用程序 969
28.1   使用数据集 969
28.1.1   VCL的数据库体系结构 970
28.1.2   BDE数据访问组件 970
28.1.3   打开一个数据集 971
28.1.4   浏览数据集 971
28.1.5   对字段操作 975
28.1.6   刷新数据集 985
28.1.7   变化的状态 986
28.1.8   过滤器 986
28.2   使用TTable组件 988
28.2.1   查找记录 988
28.2.2   主/细表 990
28.2.3   TTable的事件 990
28.2.4   通过代码创建一个数据库表 991
28.3   数据模块 992
28.4   搜索、设置范围和过滤的示例 992
28.4.1   数据模块 992
28.4.2   主窗体 993
28.4.3   Range窗体 995
28.4.4   Key Search窗体 996
28.4.5   Filter窗体 998
28.5   TQuery和TStoredProc：其他数据
          集 1000
28.6   文本文件数据库表 1001
28.6.1   概要文件 1001
28.6.2   数据文件 1002
28.6.3   使用文本数据库表 1002
28.6.4   限制 1003
28.6.5   从文本数据库表中引入数据 1003
28.7   用ODBC连接 1004
28.7.1   到哪儿找ODBC驱动程序 1004
28.7.2   ODBC实例：连接MS Access 1004
28.8   ActiveX Data Object 1007
28.8.1   Microsoft 数据访问简介 1007
28.8.2   ADOExpress组件 1008
28.8.3   连接一个ADO数据存储 1008
28.8.4   示例：通过ADO连接 1010
28.8.5   ADO开发 1011
28.9   总结 1011
第29章   开发客户/服务器应用程序 1012
29.1   为什么要采用客户/服务器结构 1012
29.2   客户/服务器体系结构 1013
29.2.1   客户 1013
29.2.2   服务器 1013
29.2.3   业务规则 1014
29.2.4   胖客户、胖服务器、中间层：业
             务规则属于哪一端 1014
29.3   客户/服务器模型 1015
29.3.1   两层模型 1015
29.3.2   三层模型 1016
29.4   客户/服务器与桌面数据库开发的比
       较 1017
29.4.1   面向集合与面向记录 1017
29.4.2   数据安全 1017
29.4.3   记录锁定方法 1017
29.4.4   数据完整性 1018
29.4.5   面向事务 1018
29.5   SQL在客户/服务器开发中的角色 1018
29.6   Delphi客户/服务器开发 1019
29.7   服务器：后端设计 1019
29.7.1   数据库对象 1019
29.7.2   定义数据库表 1020
29.7.3   使用域 1021
29.7.4   用视图、存储过程和触发器定义
             业务规则 1022
29.7.5   数据库对象的访问权限 1027
29.8   客户：前端开发 1028
29.8.1   使用TDatabase组件 1028
29.8.2   TTable还是TQuery 1034
29.8.3   使用TQuery组件 1036
29.8.4   执行存储过程 1041
29.9   总结 1043
第30章   扩展数据库VCL 1044
30.1   使用BDE 1044
30.1.1   BDE单元 1044
30.1.2   Check() 1044
30.1.3   指针和句柄 1045
30.1.4   使指针同步 1045
30.2   dBASE表 1045
30.2.1   物理记录编号 1046
30.2.2   显示被删除的记录 1047
30.2.3   测试被软删除的记录 1047
30.2.4   恢复被软删除的记录 1048
30.2.5   紧缩表 1048
30.3   Paradox表 1049
30.3.1   记录序号 1049
30.3.2   紧缩 1049
30.3.3   限制查询结果 1055
30.3.4   BDE杂项 1056
30.3.5   编写数据感知VCL控件 1059
30.4   扩展TDataSet 1063
30.4.1   过去 1063
30.4.2   现在 1063
30.4.3   创建一个TDataSet派生类 1064
30.5   总结 1083
第31章   用WebBroker使应用程序具有
         Internet功能 1084
31.1   ISAPI、NSAPI和CGI—Web服务
       器扩展 1085
31.1.1   公共网关接口 1085
31.1.2   ISAPI和NSAPI 1085
31.2   用Delphi创建Web应用程序 1086
31.2.1   TWebModule和TWeb-
             Dispatcher 1086
31.2.2   TWebRequest和TWeb-
             Response 1088
31.3   用HTML内容生成器建立动态网
       页 1091
31.3.1   TPageProducer 1091
31.3.2   TDatasetTableProducer和
             TQueryTableProducer 1092
31.4   使用cookie保存状态 1097
31.5   重定向到另一个Web站点 1099
31.6   从HTML表单中获取信息 1099
31.7   数据流 1101
31.8  总结 1104
第32章   MIDAS开发 1105
32.1   多层应用程序的结构 1105
32.2   多层体系结构的优点 1106
32.3   典型的MIDAS体系结构 1107
32.3.1   服务器 1107
32.3.2   客户 1109
32.4   用MIDAS建立应用程序 1110
32.4.1   设置服务器 1110
32.4.2   创建客户 1111
32.5   增强应用程序的更多选择 1115
32.5.1   客户优化技巧 1115
32.5.2   服务器端的技巧 1116
32.6   几个实例 1117
32.6.1   连接 1117
32.6.2   MIDAS的Web功能 1119
32.7   客户数据集的更多功能 1125
32.7.1   嵌套的数据集 1125
32.7.2   客户主/细连接 1125
32.7.3   两层应用程序 1130
32.8   部署MIDAS应用程序 1131
32.9   总结 1134
第五部分   快速开发数据库应用程序
第33章   货物管理程序：客户/服务器
         开发 1135
33.1   设计后端 1135
33.1.1   定义域 1136
33.1.2   定义表 1137
33.1.3   定义生成器 1138
33.1.4   定义触发器 1138
33.1.5   定义存储过程 1139
33.1.6   授权 1141
33.2   集中数据库访问：业务规则 1141
33.2.1   登录和退出方法 1150
33.2.2   Customer表的方法 1151
33.2.3   Part表的方法 1152
33.2.4   Sales表的方法 1152
33.2.5   临时表的方法 1153
33.2.6   TDataModule操纵数据访问
             组件的事件 1153
33.3   设计用户界面 1153
33.3.1   TMainForm：应用程序的主窗
             体 1154
33.3.2   TCustomerForm：客户输入 1158
33.3.3   TPartsForm: 货物输入 1161
33.3.4   TSalesForm: 销售浏览 1165
33.3.5   TNewSalesForm: 销售输入 1165
33.3.6   CustomerSearch对话框 1169
33.4   总结 1173
第34章   客户跟踪系统：MIDAS开发 1174
34.1   设计服务器应用程序 1174
34.2   设计客户应用程序 1176
34.2.1  客户数据模块 1176
34.2.2    客户主窗体 1184
34.3   总结 1190
第35章   错误报告工具：桌面数据库
         开发 1191
35.1   通用应用程序的需求 1191
35.1.1   为WWW做准备 1191
35.1.2   用户的数据输入和登录 1191
35.1.3   错误处理、浏览和过滤 1191
35.1.4   错误注解 1191
35.1.5   用户界面的功能 1192
35.2   数据模型 1192
35.3   开发数据模块 1192
35.3.1   应用程序初始化和登录 1201
35.3.2   生成Paradox关键值 1202
35.3.3   错误处理例程 1202
35.3.4   浏览/过滤错误 1202
35.3.5   增加用户 1202
35.3.6   加入注解 1204
35.4   开发用户界面 1205
35.4.1   主窗体 1205
35.4.2   用户界面的其他问题 1211
35.5   使应用程序具有Web功能 1211
35.6   总结 1211
第36章   错误报告工具：使用
         WebBroker 1212
36.1   网页布局 1212
36.2   修改数据模块 1213
36.3   配置TDataSetTableProducer组件：
       dstpBugs 1213
36.4   配置TWebDispatcher组件：
       wbdpBugs 1213
36.5   配置TPageProducer组件：
       pprdBugs 1214
36.6   编写DDGWebBugs ISAPI服务器：
      增加TActionItem实例 1214
36.6.1   辅助例程 1214
36.6.2   介绍网页 1215
36.6.3   获取并校验用户登录名字 1216
36.7   浏览错误信息 1219
36.7.1   浏览所有错误信息 1219
36.7.2   浏览用户自己的错误信息 1221
36.7.3   格式化表格单元并显示错误细
             节 1222
36.8   增加新的错误信息 1223
36.8.1   获取错误信息 1223
36.8.2   校验插入的错误信息 1225
36.9   总结 1228
第六部分   附      录
附录A   错误信息与异常 1229
附录B   BDE错误代码 1247
附录C   参考文献 1264
				Inprise／Borland公司的Delphi可能是当前最好的Windows快速应用程序开发工具。
随着它在Linux平台上的版本Kylix的发布，它在Unix世界的前景也十分看好。Delphi完
全支持COM、ActiveX、可视化组件库（VCL），并提供了可扩展、可定制的快速应用程
序开发环境。本书是这种功能强大的开发工具的全面参考。 
    本书从简介Delphi Pascal并讨论Delphi对象模型开始，讨论了运行时类型信息
（RTTI）——Delphi开发环境的关键部分，这一点在Delphi的其他正式帮助文档中很
少论及。本书还用一章的篇幅讨论了Delphi中的并发编程，以及多线程应用程序的创建。 
    本书的主要内容是Delphi语言以字母顺序排列的完整参考。每项参考的内容都包括：
 语法，使用标准编码惯例 说明参数列表，如果函数或过程包括参数的话提示和技巧——
在实际程序中使用某个组件的实用信息一个简单的例子其他相关关键字的交叉参考本书
秉承“坚果”（In a Nutshell系列技术手册的一贯风格。不管你对Delphi的掌握程度如何，
本书都是你日常工作中不可或缺的标准参考指南。阅读本书，你将领略到Delphi的精华所在，
还可以解决实际编程中可能遇到的问题。 
第一章 Delphi Pascal 
变量和常量 
文件1／O 
函数和过程 
第二章 Delphi对象模型 
旧式的对象类型 
第三章 运行时类型信息 
公布的声明 
.TypInfo单元 
虚方法和动态方法 
初始化和结束化 
自动的方法 
探究RTTI 
第四章 并发编程 
线程和进程 
TThread类 
BeginThread和EndThread函数 
线程局部存储 
第五章 语言参考 
第六章 系统常量 
Variant类型码 
开放数组类型 
虚方法表偏移值 
运行时错误代码 
第七章 运算符 
一元运算符 
多元运算符 
附加运算符 
比较运算符 
第八章 编译器指示字 
附录一 命令行工具 
附录二 SysUtils单元 
多谢支持【Think you to your download~】




    

				内联函数（Inlining）
D7中的inline关键字作为保留字并不会对编译器产生实际作用，在2009中此关键字起到内嵌到代码中起到实际作用。语法如下：
function foo: Integer; inline;
内部函数/过程也可以使用，但在D2009测试版中，类方法的内部函数使用inline后不认Self指针；类的子过程/子函数，也可以使用inline关键字，但没有实际效果，且虚方法/继承方法（virtual/override）不能使用。
重载运算符（Operator Overloading）
可以重载部分运算符，如+、-、类型转换等，在D2006只支持到record，但从2007开始支持到Class，以下示例修改自官网：
    TMyClass = class 
// Addition of two operands of type TMyClass 
class operator Add(a, b: TMyClass): TMyClass;  
// Subtraction of type TMyClass 
class operator Subtract(a, b: TMyClass): TMyclass;  
// Implicit conversion of an Integer to type TMyClass 
class operator Implicit(a: Integer): TMyClass;  
// Implicit conversion of TMyClass to Integer 
class operator Implicit(a: TMyClass): Integer;  
// Explicit conversion of a Double to TMyClass 
class operator Explicit(a: Double): TMyClass;   
class operator TMyClass.Add(a, b: TMyClass): TMyClass;  
begin 
//... 
    x, y: TMyClass  
begin 
    x := 12; // Implicit conversion from an Integer 
    y := x + x; // Calls TMyClass.Add(a, b: TMyClass): TMyClass 
类助手（Class Helpers）
Helper是对原Class的扩展，是我们在不修改原类的基础上增加类方法，并加入原类的空间中。在Delphi中，对对象的调用实际上采用了两个步骤，首先是把对象地址放入eax寄存器中，然后call类方法，所以如果不使用继承类增加数据的话，用父类调用继承类的方法是没问题的，所以其实这样的方法在D7中也可以使用，但却很麻烦。所以Class Helper起到的就是这个作用，在Class Helper中可以增加的就是与实例无关的内容，所以任何需要增加实例Size的活VMT的功能不能声明，例如变量、虚方法等，但只占用类空间的没关系，如class var。在应用上我们可以通过这种方法方便的给VCL一类控件加上某个属性。
  TFoo = class helper for TControl  
private 
function GetA: Integer;  
public 
class var X: Integer;  
procedure MSG(var Message: TMessage); message WM_MYMESSAGE;  
procedure ProcFoo;  
property A: Integer read GetA;  
// ... 
procedure TForm1.Foofoo; 
begin 
    ProcFoo; // TControl -> TWinControl -> TScrollingWinControl-> TCustomForm -> TForm -> TFrom1: Call TFoo.ProcFoo 
strict关键字（Keyword “strict”）
众所周知，在Delphi中，类的private和protected域中的变量可以被同一单元中可以自由的被访问（Delphi的类没有“友元”的概念，但同一个unit中可以说自动友元化了），而并非是真正的私有或只能被继承类访问。而strict关键字的作用就是使该内容变成严格OO意义上的private/protected作用域，这点没有什么多说的。语法：
strict private
// Blah...
strict protected
// Blah...
结构方法（Records with Methods）
也没什么特别的，就是和class差不多，就一个不用创建和销毁、不能继承、没有作用域之类的类，很容易掌握，所以这里就不多介绍了。但是很有意思的是带参数的constructor可以通过编译，可能是为了初始化的方便吧。
抽象类和固实类（Abstract and Sealed Classes）
这两个概念在OO中也并不陌生，抽象类是不应该创建实例的（但D2006起的编译器就不给检查，连个Warning都没有，这还有啥用啊 -.- ），而固实类是不能被继承的。语法：
TAnAbstractClass = class abstract // or (TParentClass)
// Blah...
TASealedClass = class sealed(TAnAbstractClass) // or empty
// Blah...
类常量、类变量、类属性与静态类方法（Class const/var/property and Static Class Methods）
老的Delphi中只提供了类方法，而没有提供类变量、类常量和类属性，这真的是很不方便。这里先区分一下我所使用的类（Class）和对象（Object）即类的实例（Instance of Class）。当在Delphi中声明一个类的时候，这个类是有实际地址的，该地址记录了许多类的相关信息，比如实例的Size啊、虚方法信息啊一堆东西，而创建一个对象的时候则把类实例化，在堆（Heap）中分配一块地址，包括内部数据和VMT之类的东西。在调用实例的时候，首先要知道对象地址，然后才能访问内部变量和调用方法时使用Self指针即实例地址；而在调用类方法的时候，eax中的并不是实例的地址而是类的地址，然后再call方法，这时的Self指针并非实例地址而是类地址。所以对于每一个类和继承类来说，包括它和它的继承类的所有实例，类变量、常量都是同一个，这样就存在了一个唯一的可供使用的变量或常量，方便同步并且不需要使用较多的内存（可以参考C#中的类，不过C#中不允许从实例直接访问类变量、常量、方法）。而静态类方法则是在使用这个类方法的时候不传入class地址，也就是说没有Self指针，这样的类方法的访问开销要小于普通的类方法；这自然也就意味着，该类方法不能被继承（不能virtual/override）。另外，类属性的get/set方法必须使用静态类方法。
TFooClass = class 
private 
class procedure SetFoo(const Value: Integer); static; // A Static Class Method 
protected 
class var FX : Integer; // class var 
public 
const FC: Integer = 10; // class const 
class procedure VirtualProc; virtual; 
class property X: Integer read FX write FX; // class property 
class property Foo: Integer read FC write SetFoo; 
类内部类型与嵌套类（Class Types and Nested Classes）
可以说现在的Class的域几乎相当于原来的整个unit，以前不能放里面的元素现在都可以放里面了，这个也没什么好多说的，试验一下就很容易明白了。
终方法（Final Methods）
这个也是建立在虚方法的基础上的，在override后使用final关键字，则表示该虚方法不能再被子类继承下去了。
  TAClass  = class 
public 
procedure Foo; virtual; 
  TFinalMethodClass  = class(TAClass) 
public 
procedure Test; override; final; // A Final Method 
For-in循环（For-in Loop）
这个应该是受.Net影响吧，支持遍历一个数组或提供了GetEnumerator函数的类。GetEnumerator要求返回一个类的实例，该类包含有Current属性和MoveNext方法。
procedure Foo(List: TStrings); 
  i : Integer; 
  lst : array[0..100]of Integer; 
  s : string; 
begin 
for i in lst do ;
for s in List do ; // Support of TStrings.GetEnumerator
				https://wenda.so.com/q/1535561587217078delphi数组如何初始化rosegirl09112级分类：其他被浏览44次2018.07.01检举满意答案
csx3308362采纳率：42%9级 2018.07.02vari : integer;arr1 : array[0..9] of integer;arr2 : array[0..9] of char;beg...
				varA:Array[0..10]ofInteger;{定义静态数组} procedureTForm1.Button1Click(Sender:TObject); vari:Integer; begin Memo1.Clear; fori:=Low(A)toHigh(A)do begin Randomize; 
A[i]:=Ra...
				在有了泛型容器之后我个人使用数组的频率越来越低，但是作为一种应用时间最长、范围最大的容器类型还是有必要掌握的
数组类型定义了一组指定类型的元素序列，在方括号中填入下标值就可访问数组中的元素。定义数组时，方括号也用来指定可能的下标值。例如，下面的代码中定义了一个有24个整数的数组：
//声明方式一
  DayTemperatures = array [1..24] of Integer;
//声明方式二
  Names: array [1 .. 3] of string;
				dctb:array[1..2,1..38] of Single=((0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0),
(0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0)
）；...
Procedure ArrayExamples;
const
  DaysOfWeek : array[1..7] of string = ('Sunday', 'Monday', 'Tuesday',
	'Wednesday', 'Thursday', 'Friday', 'Saturday' );
  MonthsOfYear : array[1..12] of str
				1.       如果想你的程序能够正确处理异常情况的话，请引用SysUtils.pas单元，否则即使程序使用了try。。。except。。。也不能正确捕获异常。
2.       定义常量字符串的一种方式
resourcestring
    aa='aaaa';
raise Exception.CreateRes(@aa);
3.       字符串常量数组的初始化
const
				Delphi获取WM_COPYDATA消息的方法如下：
1. 首先需要创建一个窗口来接收这个消息。可以使用TForm或TApplication等Delphi窗口类来创建窗口。
2. 在窗口类中，重写WndProc方法。WndProc方法是窗口消息处理程序，用于接收和处理所有窗口消息，包括WM_COPYDATA消息。
3. 在WndProc方法中，判断接收到的消息类型是否为WM_COPYDATA消息。如果是，则通过指针参数lpCopyDataStruct获取传递过来的数据。lpCopyDataStruct是一个指向COPYDATASTRUCT结构体的指针，里面包含了传递过来的数据。
4. 在获取到数据之后，就可以对其进行处理了。处理方式根据具体需求而定，可以将数据显示在窗口上，或者进行其他操作。
示例代码：
interface
  TForm1 = class(TForm)
  private
    { Private declarations }
    procedure WMCopyData(var Msg: TWMCopyData); message WM_COPYDATA;
  public
    { Public declarations }
  Form1: TForm1;
implementation
{$R *.dfm}
procedure TForm1.WMCopyData(var Msg: TWMCopyData);
  CopyDataStruct: PCOPYDATASTRUCT;
begin
  CopyDataStruct := Msg.CopyDataStruct;
  if (CopyDataStruct^.dwData = 12345) then //假设这里传递的是一个整数型数据，值为12345
  begin
    //处理传递过来的数据
在上面的示例代码中，当接收到WM_COPYDATA消息时，会判断传递过来的数据是否为整数型数据，并进行相应处理。在实际应用中，可以根据具体情况来修改代码，实现自己想要的功能。