DELPHI学习---结构类型

Structured types (结构类型)

结构类型的一个实例可包含多个值。结构类型包括集合、数组、记录，也包括类、类引用（class-reference）

和接口类型。除了集合只能包含有序值以外，结构类型可以包含其它的结构类型，且结构的层次不受限

制。

默认情况下，一个结构类型的值被圆整为字（word）或者双字（double-word），这样访问起来更迅速。

当声明一个结构类型时，可以包含关键字packed，这将对数据的存储进行压缩（并不是压缩，只是不再

圆整数据，而保留它的自然结构）。比如：

type TNumbers = packed array[1..100] of Real;

使用packed 使数据访问变慢，并且在使用字符数组的情况下，能影响类型兼容性。

{*-----------------------------------------------------------------------------------------

Packed关键字是与编译有关的！！！

在默认情况下，Delphi编译器是对数据进行优化的！！！

例如：

TX = Record

A : Char;

B : Integer;

End;

在这个记录中，TX的大小应该是5个字节，但是由于Delphi的优化，Tx的大小变成了8个字节，所以为了得到

TX的真实大小，这个时候就要使用Packed关键字了，禁止进行优化！！！一般Packed关键字在使用C++/C的

API汉书中用得比较多，一般Delphi内部自己的程序不需要使用Packed关键字，除非你想得到某个对象的真实大小！！！

为什么优化：

举一个现实生活中的例子，假设有两个杯子，一个装满了水，另一个只装了1/3的水，那么实际物理上这些水

占用了两个杯子，因为我们不能说占了4/3的杯子，因为我们没办法得到2/3的杯子。在这一杯子就是CPU中的寄

存器，TX对象中的A，虽然只有一个字节，但它却占用了一个寄存器的空间(4个字节，这就是32位计算机，如果

是64位计算机，一个寄存器的大小将变成8个字节)，所以经过优化的结果是TX的大小是8。优化的数据可以提高

执行效率，因为我们不必关心杯子里到底有多少水，1/4？1/3？1/2...，我们只要关心那些水占据了一个杯子，

这样会节省大量的分析杯子里有多少水的时间！！！这就是Packed的作用！！！

加Packed就是为了

1、使用sizeOf得到记录的真实大小。

2、节省内存空间。

3、保证与其他程序通讯的正确性。

....

比如你编写一个通讯程序，定义的记录大小为10用来存储现金，如果这时你让Delphi优化

了这个记录，天知道金额会变成什么！！！

packed record

是压缩记录类型

----------------------------------------------------------------------------------------*}

Sets（集合）

集合是同一种有序类型的值的聚集，它们包含的值没有内在的顺序，且一个值在集合中包含两次并没有

实际意义。

一个集合类型的取值范围，是构成它的有序类型（称为基础类型）的幂，也就是说，集合可能的值是基

础类型的所有子集，也包含空集。基础类型可能的值不要超过256 个，并且它们的序数必须在0 到255

之间。任何像下面的形式：

set of baseType

声明一个集合类型，这里，baseType 是一个合适的有序类型。

因为基础类型的值是有限的，因此，集合类型通常使用子界类型来定义。比如下面的声明：

type

TSomeInts = 1..250;

TIntSet = set of TSomeInts;

它声明一个叫做TIntSet 的集合类型，它的值是从1 到250 之间所有可能的选择。你也可以使用下面的语

句达到同样的目的：

type TIntSet = set of 1..250; //用set of 的形式定义

有了上面的声明，你就可以像下面这样构造集合了：

var Set1, Set2: TIntSet;

...

Set1 := [1, 3, 5, 7, 9]; //集合用[]来赋值

Set2 := [2, 4, 6, 8, 10]

你也可以直接使用set of …构造直接声明变量：

var MySet: set of 'a'..'z';

...

MySet := ['a','b','c'];

其它集合类型的实例包括：

set of Byte

set of (Club, Diamond, Heart, Spade)

set of Char;

运算符in 判断集合的成员关系：

if 'a' in MySet then ... { do something } ;

每个集合类型可包含空集，用[]来表示。

Arrays（数组）

一个数组是由相同类型的（称为基础类型）、经过索引的元素组成的聚集。因为每个元素有唯一的索引，

所以，数组和集合不同，它可以包含多个相同的值。数组可以静态分配内存，也可以动态分配。

Static arrays（静态数组）

静态数组类型以下面的格式声明：

array[indexType1, ..., indexTypen] of baseType

这里，每个indexType 是有序类型并且范围不超过2G。因为indexType 是数组的索引，所以，数组包含

的元素个数由indexType 的范围限定。在实际应用中，indexType 通常是整数子界类型。

最简单的是一维数组，它只有一个indexType，比如：

var MyArray: array[1..100] of Char;

声明了一个变量MyArray，它是一个有100 个字符的数组。给定上面的声明，MyArray[3]表示数组中的

第3 个字符。若声明了一个静态数组，虽然并没有给每一个元素赋值，但未用的元素仍分配内存并包含

一个随机值，这和未初始化的变量类似。

A multidimensional array is an array of arrays. For example,

一个多维数组是数组的数组，比如：

type TMatrix = array[1..10] of array[1..50] of Real;

就等价于

type TMatrix = array[1..10, 1..50] of Real;

不论用哪种方式声明，它表示一个有500 个实数值的数组。一个TMatrix 类型的变量MyMatrix，可使用

这样的索引：MyMatrix[2,45]，或像这样：MyMatrix[2][45]。同样，

packed array[Boolean,1..10,TShoeSize] of Integer;

就等价于

packed array[Boolean] of packed array[1..10] of packed array[TShoeSize] of

Integer;

标准函数Low 和High 作用于数组类型（的标志符）或变量，它们返回数组第1 个索引（类型）的最小

值和最大值；Length 返回数组第1 维的元素个数。

一维、

一维、压缩的（packed）、Char 类型的静态数组称为packed string，它和字符串类型兼容，也和其它具有

相同元素个数的packed string 兼容。请参考Type compatibility and identity。

array[0..x] of Char 类型的数组，是0 下标开始的字符数组，它用来存储零结尾字符串，并且和PChar 类

型兼容。参考Working with null-terminated strings。

Dynamic arrays（动态数组）

动态数组没有固定大小和长度，相反，当你给它赋值或把它传给SetLength 函数时，它的内存被重新分

配。动态数组以下面的形式声明：

array of baseType

比如

var MyFlexibleArray: array of Real;

声明一个实数类型的一维动态数组。声明并没有为MyFlexibleArray 分配内存，要在内存中创建数组，要

调用SetLength。比如，以上面的声明为例：

SetLength(MyFlexibleArray, 20);

分配一个由20 个实数构成的数组，索引号从0 到19。动态数组的索引总是整数，并从0 开始。动态数

组变量实际是指针，并和长字符串一样使用引用计数进行管理。要取消动态数组的分配，给它的变量赋

值nil，或者把变量传给Finalize。在没有其它引用的情况下，这两种方法都将消除数组。0 长度动态数

组的值为nil。不要对一个动态数组变量使用运算符‘^’，也不要对它使用New 或Dispose 过程。

若X 和Y 是同一类型的动态数组变量，X := Y 使X 指向和Y 相同的数组（在这个操作之前，不必给X

分配内存）。不像字符串和静态数组，动态数组不会在被写之前自动拷贝。比如，在下面的代码执行后

var

A, B: array of Integer;

begin

SetLength(A, 1);

A[0] := 1;

B := A;

B[0] := 2;

end;

A[0]的值是2（若A 和B 是静态数组，A[0]仍然是1）。

使用索引给动态数组赋值（比如，MyFlexibleArray[2] := 7），不会为数组重新分配内存；编译时，索引

边界检查也不会给出提示。

当比较动态数组变量时，是比较它们的引用（这里的值是一个地址），而不是它们的值。所以，下面的代

码执行后

var

A, B: array of Integer;

begin

SetLength(A, 1);

SetLength(B, 1);

A[0] := 2;

B[0] := 2;

end;

A = B 返回False，但A[0] = B[0]返回True。

要截断一个动态数组，把它传给SetLength 或Copy，并把返回的值赋给数组变量（SetLength 通常更快）。

比如，若A 是一个动态数组，执行A := SetLength(A, 0, 20)，除A 的前20 个元素外，其它都将被截取掉。

一旦一个动态数组被分配内存，你可以把它传给几个标准函数：Length、High 和Low。Length 返回数组

的元素个数，High 返回最大数组的最大索引（也就是Length-1），Low 返回0。对于长度为0 的数组，

High 返回-1（得到反常结果High < Low）。

注意：有些函数或过程在声明时，数组参数表示为array of baseType，没有指明索引类型。比如，

function CheckStrings(A: array of string): Boolean;

这表明，函数可用于（指定的）基础类型的所有数组，而不管它们的大小和索引，也不管它们是静态分

配还是动态分配。请参考Open array parameters。

Multidimensional dynamic arrays（多维动态数组）

要声明多维动态数组，使用复合array of ... 结构，比如，

type TMessageGrid = array of array of string;

var Msgs: TMessageGrid;

声明一个二维字符串数组。要实例化这个数组，应用两个整数参数调用SetLength。比如，若I 和J 是整

数变量，

SetLength(Msgs,I,J);

给它分配内存，Msgs[0,0]表示它的一个元素。

你也能创建不规则的多维动态数组。第一步是调用SetLength，给它传递参数作为前面的（几个）索引。

比如，

var Ints: array of array of Integer;

SetLength(Ints,10);

为Ints 分配了10 行，但没有分配列。接下来，你能每次分配一个列（给它们指定不同的长度），比如，

SetLength(Ints[2], 5);

使Ints 的第3 行有5 个元素。此时（即使其它列没有被分配），你能给它的第3 行赋值，比如，Ints[2,4] :=

6。

下面的例子使用动态数组（IntToStr 函数在SysUtils 单元声明）来创建一个字符串的三角形矩阵。

var

A : array of array of string;

I, J : Integer;

begin

SetLength(A, 10);

for I := Low(A) to High(A) do

begin

SetLength(A[I], I);

for J := Low(A[I]) to High(A[I]) do

A[I,J] := IntToStr(I) + ',' + IntToStr(J) + ' ';

end;

end;

Array types and assignments（数组类型和赋值）

Arrays are assignment-compatible only if they are of the same type. Because Pascal uses name-equivalence for

types, the following code will not compile.

只有数组是相同类型时，它们才是赋值兼容的。因为Pascal 使用‘名称’代表‘类型’，所以下面的代

码无法编译：

Data types, variables and constants

- 59 -

var

Int1: array[1..10] of Integer;

Int2: array[1..10] of Integer;

...

Int1 := Int2;

要使赋值能够工作，要如下声明变量

var Int1, Int2: array[1..10] of Integer;

或

type IntArray = array[1..10] of Integer;

var

Int1: IntArray;

Int2: IntArray;

Records（记录）

记录（类似于其它语言中的结构）表示不同种类的元素的集合，每个元素称为“字段”，声明记录类型时

要为每个字段指定名称和类型。声明记录的语法是

type recordTypeName = record

fieldList1: type1;

...

fieldListn: typen;

end

这里，recordTypeName 是一个有效标志符，每个type 表示一种类型，每个fieldList 是一个有效标志符或

用逗号隔开的标志符序列，最后的分号是可选的。（哪个分号？是最后一个字段的，还是end 后面的？）

比如，下面的语句声明了一个记录类型TDateRec：

type

TDateRec = record

Year: Integer;

Month: (Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec);

Day: 1..31;

end;

TDateRec 包含3 个字段：一个整数类型的Year，一个枚举类型的Month，和另一个子界类型的Day。标

志符Year、Month 和Day 是TDateRec 的字段，它们的行为就像变量。声明并不会为Year、Month 和Day

分配内存，只有在实例化时才进行分配，像下面的样子：

var Record1, Record2: TDateRec;

上面的变量声明创建了两个TDateRec 实例，分别叫做Record1 和Record2。

你可以用记录名作限定符、通过字段名来访问字段：

Record1.Year := 1904;

Record1.Month := Jun;

Record1.Day := 16;

或使用with 语句：

with Record1 do

begin

Year := 1904;

Month := Jun;

Day := 16;

end;

现在，你可以把Record1 的值拷贝给Record2：

Record2 := Record1;

因为字段名的范围被限定在记录本身，你不必担心字段名和其它变量发生冲突。

Instead of defining record types, you can use the record ... construction directly in variable declarations:

除了定义记录类型，你也可以使用record ...构造直接声明变量：

var S: record

Name: string;

Age: Integer;

end;

但是，这样不能让你重复使用类型声明，并且，这样声明的类型不是赋值兼容的，即使它们（记录）的

结构完全相同。

Variant parts in records（记录中的变体部分，变体记录）

一个记录类型能拥有变体部分，它看起来就像case 语句，在声明中，变体部分必须跟在其它字段的后面。

要声明一个变体记录，使用下面的语法：

type recordTypeName = record

fieldList1: type1;

...

fieldListn: typen;

case tag: ordinalType of

constantList1: (Variant1);

...

constantListn: (Variantn);

end;

声明的前面部分（直到关键字case）和标准记录类型一样，声明的其余部分（从case 到最后一个可选的

分号，）称为变体部分，在变体部分

???? tag 是可选的，它可以是任何有效标志符。如果省略了tag，也要省略它后面的冒号（:）。

???? ordinalType 表示一种有序类型。

???? 每个constantList 表示一个ordinalType 类型的常量，或者用逗号隔开的常量序列。在所有的常量

中，一个值不能出现多次。

???? 每个Variant 是一个由逗号隔开的、类似于fieldList: type 的声明列表，也就是说，Variant 有下面

的形式：

fieldList1: type1;

...

fieldListn: typen;

这里，每个fieldList 是一个有效标志符，或是由逗号隔开的标志符列表，每个type 表示一种类型，

最后一个分号是可选的。这些类型不能是长字符串、动态数组、变体类型或接口（都属于动态管

理类型），也不能是包含上述类型的结构类型，但它们可以是指向这些类型的指针。

变体记录类型语法复杂，但语义却很简单：记录的变体部分包含几个变体类型，它们共享同一个内存区

域。你能在任何时候，对任何一个变体类型的任何字段读取或写入，但是，当你改变了一个变体的一个

字段，又改变了另一个变体的一个字段时，你可能覆盖了自己的数据。如果使用了tag，它就像记录中

非变体部分一个额外的字段，它的类型是ordinalType。

变体部分有两个目的。首先，假设你想创建这样一个记录：它的字段有不同类型的数据，但你知道，在

一个（记录）实例中你永远不需要所有的字段，比如：

type

TEmployee = record

FirstName, LastName: string[40];

BirthDate: TDate;

case Salaried: Boolean of

True: (AnnualSalary: Currency);

False: (HourlyWage: Currency);

end;

这里的想法是，每个雇员或者是年薪，或者是小时工资，但不能两者都有。所以，当你创建一个TEmployee

的实例时，没必要为每个字段都分配内存。在上面的情形中，变体间的唯一区别在于字段名，但更简单

的情况是字段拥有不同的类型。看一下更复杂的例子：

type

TPerson = record

FirstName, LastName: string[40];

BirthDate: TDate;

case Citizen: Boolean of

True: (Birthplace: string[40]);

False: (Country: string[20];

EntryPort: string[20];

EntryDate, ExitDate: TDate);

end;

type

TShapeList = (Rectangle, Triangle, Circle, Ellipse, Other);

TFigure = record

case TShapeList of

Rectangle: (Height, Width: Real);

Triangle: (Side1, Side2, Angle: Real);

Circle: (Radius: Real);

Ellipse, Other: ();

end;

对每个记录类型的实例，编译器分配足够的内存以容纳最大变体类型的所有字段。可选的tag 和

constantLists（像上面例子中的Rectangle、Triangle 等）对于编译器管理字段没有任何作用，它们只是为

了程序员的方便。

使用变体记录的第二个原因是，你可以把同一个数据当作不同的类型进行处理，即使在编译器不允许类

型转换的场合。比如，在一个变体类型中，它的第一个字段是64 位实数，在另一个变体类型中，第一个

字段是32 位整数，你可以把一个值赋给实数（字段），然后再当作整数来读取它的前32 位值（比如，把

它传给一个需要整数参数的函数）。

File types（文件类型）

file 是由相同类型的元素组成的有序集合。标准I/O 例程使用内置（预定义）的TextFile 或Text 类型，它

们表示一个包含字符的文件，这些字符是以行的形式进行组织的。想了解更多关于文件输入和输出的信

息，请参考Standard routines and I/O（标准例程和I/O）。

要声明一个文件类型，使用下面的语法：

type fileTypeName = file of type

这里，fileTypeName 是任何有效的标志符，type 是一个固定大小的类型。指针类型（不管是隐含的还是

直接的）是不可以的，所以，文件不能包含动态数组、长字符串、类、对象、指针、变体类型、其它文

件或包含以上类型的结构类型。

比如，

type

PhoneEntry = record

FirstName, LastName: string[20];

PhoneNumber: string[15];

Listed: Boolean;

end;

PhoneList = file of PhoneEntry;

声明了一个记录姓名和电话号码的文件类型。

在声明变量时，你也可以直接使用file of ...结构，比如，

var List1: file of PhoneEntry;

单独的一个file 表示一个无类型文件：

var DataFile: file;

要了解更多信息，请参考Untyped files（无类型文件）。

数组和记录中不能包含文件类型。

Pointers and pointer types（指针和指针类型）

指针是一个表示内存地址的变量。当一个指针包含另一个变量的地址时，我们认为它指向这个变量在内

存中的位置，或指向数据存储的地方。对于数组或其它结构类型，指针指向的是结构中第一个元素的地

址。

指针被类型化以表示在它指定的位置上存储某一类型的数据。Pointer 类型表示一个任意类型的指针，而

指定类型的指针只表示特定类型的数据。指针在内存中占据4 个字节。

要了解指针如何工作，看下面的例子：

1 var

2 X, Y: Integer; // X 和Y 是整数变量

3 P: ^Integer; // P 指向一个整数

4 begin

5 X := 17; // 给X 赋值

6 P := @X; // 把X 的地址赋给P

7 Y := P^; // dereference P；把结果赋给Y

8 end;

第2 行声明X 和Y 为整数类型的变量，第3 行声明P 是一个指向整数的指针，这表明P 可以指向X 或

Y 的存储位置。第5 行把一个值赋给X，第6 行把X 的地址（用@X 表示）赋给P。最后，在第7 行，

取得P 所指位置的值（用P^表示）并把它赋给Y。这些代码执行后，X 和Y 有相同的值，即17。

@运算符，这里我们用来取得一个变量的地址，它同样可用于函数或过程。

^符号有两个用途，在我们的例子中都用到了。当它出现在一个类型标志符前面时：

^typeName

它表示一个指向typeName 类型的变量的指针；当它出现在一个指针变量的后面时：

pointer^

它表示对指针解除引用，换句话说，它返回在指针所指向的地址处保存的值。

我们的例子看起来是在兜圈子，它只不过是把一个变量的值复制给另一个变量而已，我们完全可以通过

一个简单的赋值语句来完成，但指针有几个用途：首先，理解指针能帮助你理解Object Pascal，因为经

常在代码中虽然没有明确使用指针，但它们却在背地里发挥作用。使用大的、动态分配内存（块）的任

何数据类型都使用指针。例如，长字符串就是一个隐含的指针，类变量也是；此外，一些高级的编程技

术需要使用指针。

最后，指针有时是跳过Object Pascal 严格的（数据）类型匹配的唯一方法。使用一个通用指针（Pointer）

来引用一个变量，并把它转换为其它类型，然后重新引用它，这样你就可以把它作为任何类型对待。比

如，下面的代码把一个实数变量的值赋给一个整数变量。

type

PInteger = ^Integer;

var

R: Single;

I: Integer;

P: Pointer;

PI: PInteger;

begin

...

P := @R;

PI := PInteger(P);

I := PI^;

end;

当然，实数和整数有不同的存储格式，上面的赋值只简单地把R 的二进制数据赋给I，并不是实际转换。

除了使用@运算符，你也可以使用几个标准例程给一个指针赋值。New 和GetMem 过程把一个内存地址

赋给指针，而Addr 和Ptr 函数则返回一个指向特定变量或地址的指针。

像P1^.Data^表示的那样，对指针解除引用可用作限定符，也可以被限定。

保留字nil 是一个特殊常量，可赋给任何指针（类型）。当nil 被赋给一个指针时，指针不表示任何东西。

Pointer types（指针类型）

使用下面的语法，你能声明一个任意类型的指针，

type pointerTypeName = ^type

当定义一个记录类型（或其它数据类型）时，习惯上也就定义了一个此类型的指针，这使得处理更容易，

我们不需要拷贝一大块内存。

标准指针类型有许多理由存在，最通用的是Pointer，它可以指向任何数据类型，但不能对它解除引用，

在Pointer 类型变量的后面使用^运算符会引发编译错误。要访问一个Pointer 类型引用的变量，首先把它

转换为其它指针类型，然后再解除引用。

Character pointers（字符指针）

基本（fundamental）类型PAnsiChar 和PWideChar 分别表示AnsiChar 和WideChar 值的指针，一般（generic）

类型PChar 表示一个指向Char 的指针（在当前实现中，它表示AnsiChar）。这些字符指针用来操纵零结

尾字符串（参考Working with null-terminated strings）。

Procedural types（过程类型）

过程类型允许你把过程和函数作为“值”看待，它可以赋给变量或传给其它过程和函数。比如，假设你

定义了一个叫做Calc 的函数，它有两个整型参数并返回一个整数值：

function Calc(X,Y: Integer): Integer;

你可以把Calc 函数赋给变量F：

var F: function(X,Y: Integer): Integer;

F := Calc;

我们只取过程或函数头（heading）并把procedure 或function 后面的标志符去掉，剩下的就是过程类型

的名称。你可以在声明变量时直接使用这样的名称（就像上面的例子一样），也可以声明新类型：

type

TIntegerFunction = function: Integer;

TProcedure = procedure;

TStrProc = procedure(const S: string);

TMathFunc = function(X: Double): Double;

var

F: TIntegerFunction; {F 是一个无参数、返回整数值的函数}

Proc: TProcedure; { Proc 是一个无参数过程}

SP: TStrProc; { SP 是一个使用string 类型参数的过程}

M: TMathFunc; { M 是一个使用Double 类型参数、返回Double 值的函数}

procedure FuncProc(P: TIntegerFunction); { FuncProc 是一个过程，它的参数是

一个无参数、返回整数值的函数}

上面的所有变量都是过程指针，也就是指向过程或函数地址的指针。若想引用一个实例对象的方法（参

考Classes and objects），你需要在过程类型的名称后面加上of object。比如

type

TMethod = procedure of object;

TNotifyEvent = procedure(Sender: TObject) of object;

这些类型表示方法指针。方法指针实际上是一对指针：第一个存储方法的地址，第二个存储方法所属的

对象的引用。给出下面的声明

type

TNotifyEvent = procedure(Sender: TObject) of object;

TMainForm = class(TForm)

procedure ButtonClick(Sender: TObject);

...

end;

var

MainForm: TMainForm;

OnClick: TNotifyEvent

我们就可以进行下面的赋值：

OnClick := MainForm.ButtonClick;

两个过程类型是兼容的，如果它们具有

???? 相同的调用约定，

???? 相同类型的返回值（或没有返回值），并且具有

???? 相同数目的参数，并且相应位置上的类型也相同（参数名无关紧要）

过程指针和方法指针是不兼容的。nil 可以赋给任何过程类型。

嵌套的过程和函数（在其它例程中声明的例程）不能被用作过程类型值，内置的过程和函数也不可以。

若想使用内置的过程作为过程类型值，比如Length，你可以给它加一个包装：

function FLength(S: string): Integer;

begin

Result := Length(S);

end;

Procedural types in statements and expressions（语句和表达式中的

过程类型）

当一个过程变量出现在赋值语句的左边时，编译器期望右边是一个过程类型值。赋值操作把左边的变量

当作指针，它指向右边指示的过程或函数。但在其它情形，使用过程变量将调用它引用的过程或函数，

你甚至可以对过程变量传递参数：

var

F: function(X: Integer): Integer;

I: Integer;

function SomeFunction(X: Integer): Integer;

...

F := SomeFunction; // 把SomeFunction 赋给F

I := F(4); // 调用函数，把结果赋给I

在赋值语句中，左边变量的类型决定右边的过程（或方法）指针的解释，比如

var

F, G: function: Integer;

I: Integer;

function SomeFunction: Integer;

...

F := SomeFunction; // 把SomeFunction 赋给F

G := F; // 拷贝F 到G

I := G; // 调用函数，把结果赋给I

第1 个赋值语句把一个过程类型值赋给F，第2 个语句把这个值拷贝给另一个变量，第3 个语句调用引

用的函数并把结果赋给I。因为I 是一个整数变量，而不是过程类型，所以最后的赋值实际上是调用函数

（它返回一个整数值）。

在一些情况下，如何解释过程变量并不是很清楚，看下面的语句

if F = MyFunction then ...;

在此情况下，F 导致函数调用：编译器调用F 指向的函数，然后调用函数MyFunction，然后比较结果。

规则是，只要过程变量出现在表达式中，它就表示是调用引用的过程或函数。在上面的例子中，若F 引

用一个过程（没有返回值），或F 引用的函数需要参数，则引发编译错误。要比较F 和MyFunction 的过

程值，使用

if @F = @MyFunction then ...;

@F 把F 转换为无类型指针变量，它包含的是地址，@MyFunction 返回的是MyFunction 的地址。

要取得过程变量的内存地址（而不是它包含的地址），使用@@。比如，@@F 返回F 的地址。

@运算符也可以用来把一个无类型指针值赋给过程变量，比如

var StrComp: function(Str1, Str2: PChar): Integer;

...

@StrComp := GetProcAddress(KernelHandle, 'lstrcmpi');

调用GetProcAddress 函数，并使StrComp 指向结果。

过程变量可以是nil 值，但此时调用它会引发错误。要测试一个过程变量是否被赋值，使用标准函数

Assigned：

if Assigned(OnClick) then OnClick(X);

Declaring types（声明类型）

一个类型声明指定一个标志符，来表示一种数据类型。类型声明的语法为

type newTypeName = type

这里，newTypeName 是一个有效的标志符。比如，给定如下的类型声明

type TMyString = string;

你就可以声明变量

var S: TMyString;

一个类型标志符的范围不能包含类型声明本身（指针类型除外），所以举例来说，你不能在声明一个记录

时循环使用它。

当声明一个和已有类型完全相同的类型时，编译器把它看作是已有类型的别名。这样，在下面的声明中

type TValue = Real;

var

X: Real;

Y: TValue;

X 和Y 属于相同的类型。在运行时，没有办法区分TValue 和Real 类型。这通常有一些意义，但如果你

定义新类型的目的是利用RTTI（Runtime Type Information），比如，给某个类型赋一个属性编辑器，区

分‘不同名称’和‘不同类型’就变得重要了。这种情况下，你使用语法

type newTypeName = type type

例如

type TValue = type Real;

这将强制编译器创建一个不同的新类型TValue。