Delphi - Record记录和变体记录

源码资源网

Delphi - Record记录和变体记录

1. //Integer类型刚好是4个字节,ShortInt类型是1个字节，但是Windows中内存是4字节分配，
   
2. 
   
3. //所以这里其实还是4个字节，用SizeOf可以看到这个record的大小是8字节，这样虽然浪
   
4. 
   
5. //费了空间，但是加快了速度(Windows内存分配中的边界对齐原理)
   
6. 
   
7. TPerson = record
   
8. 
   
9. Age: Integer;
   
10. 
    
11. Sex: ShortInt;
    
12. 
    
13. end;
    
14. 
    
15. TPackedPerson = packed record
    
16. 
    
17. Age: Integer;
    
18. 
    
19. Sex: ShortInt; //使用packed record，用Sizeof可以看到这个record的大小是5字节；
    
20. 
    
21. end;
    
22. 
    
23. 
    
24. 
    
25. TEmployee = record
    
26. 
    
27. ID: Integer; //Integer是4字节
    
28. 
    
29. case Integer of
    
30. 
    
31. 0:(YearMoney: Integer); //YearMoney和MonthMoney共用内存，按最大内存分配
    
32. 
    
33. 1:(MonthMoney: ShortInt); //该record的大小是8字节
    
34. 
    
35. end;
    
36. 
    
37. 
    
38. 
    
39. TTagEmployee = record
    
40. 
    
41. ID: Integer;
    
42. 
    
43. case Grade: Integer of //这里加入了Grade变量
    
44. 
    
45. 0:(YearMoney: Integer); //YearMoney和MonthMoney共用内存，按最大内存分配
    
46. 
    
47. 1:(MonthMoney: ShortInt); //该record的大小是12字节(ID+Grade+YearMoney)
    
48. 
    
49. end;

复制代码

1.在DELPHI中，我们用record关键字来表明一个记录，有时候，我们还会看到用packed record来声明的记录，这二者的区别就在于存储方式的不同；在windows中，内存的分配一次是4个字节的，而Packed按字节进行内存的申请和分配，这样速度要慢一些，因为需要额外的时间来进行指针的定位。因此如果不用Packed的话，Delphi将按一次4个字节的方式申请内存，因此如果一个变量没有4个字节宽的话也要占4个字节！这样浪费了一些空间，但提高了效率。

2.变体记录的规则：

       （1）Long  String、WideString、Dynamic  Array、Interface的大小都是指针大小，OleVariant其实就是COM  SDK中的VARIANT结构，大小是16字节。但在Object  Pascal中它们都需要自动终结化，如果它们出现在variant  part中，编译器就无法知道它们是否应该进行终结化――因为不知道当前存储的是哪种类型，因此他们不能出现在变体记录类型中，或者用类似String[10]来定义；

（2）所有变体字段共享一段内存，而共享内存的大小则由最大变体字段决定—“最长”的变量决定；

（3）当tag存在时，它也是记录的一个字段。也可以没有tag。

（4）记录的变体部分的条件域必须是有序类型——Case后面跟的类型必须是Boolean，Integer等等有序类型。

（5）记录类型中可以含有变体部分，有点象case语句，但没有最后的end，变体部分必需在记录中其他字段的声明之后。

3.最经典的变体记录，Delphi中的TMessage结构：

变体结构也就是变体记录, 是一个比较复杂的概念. 专家不提倡使用.

一个最大的无符号整数(Cardinal)是 4294967295, 它的大小是 4 字节, 它的二进制表示是:

11111111 11111111 11111111 11111111

它的低字节的值是 11111111, 也就是十进制的 255

1. //测试:
   
2. 
   
3. var
   
4. 
   
5. c: Cardinal;
   
6. 
   
7. begin
   
8. 
   
9. c := 4294967295;
   
10. 
    
11. ShowMessage(IntToStr(Lo(c))); {会显示: 255; Lo 是获取低字节值的函数}
    
12. 
    
13. end;

复制代码

一个 Byte 类型的最大值是 255, 它的大小是 1 个字节, 用二进制表示是:11111111

假如把一个 Cardinal 类型的值赋给一个 Byte 类型的值, Byte 将只取 Cardinal 的最低字节.

1. //测试:
   
2. 
   
3. var
   
4. 
   
5. c: Cardinal;
   
6. 
   
7. b: Byte;
   
8. 
   
9. begin
   
10. 
    
11. c := 4294967295;
    
12. 
    
13. b := c;
    
14. 
    
15. ShowMessage(IntToStr(b)); {255}
    
16. 
    
17. 
    
18. 
    
19. c := 258; {二进制表示: 00000000 00000000 00000001 00000010}
    
20. 
    
21. b := c; {b 将只获取: 00000010}
    
22. 
    
23. ShowMessage(IntToStr(b)); {2}
    
24. 
    
25. end;

复制代码

这是我们能否会想到, 在结构会储存时, 一个可以储存 Cardinal 的空间, 当然也能得放下一个 Byte 值;

如果这个值非此即彼, 我们完全不需要两个储存空间.

我猜测, 这应该是 Delphi 设计变体记录的初衷.

1. //假如有这样一个员工登记表
   
2. 
   
3. type
   
4. 
   
5. TpersonRec = record
   
6. 
   
7. ID: Integer; {员工编号}
   
8. 
   
9. case Boolean of {根据分类}
   
10. 
    
11. True: (A: Cardinal); {如果是股东, 登记年薪}
    
12. 
    
13. False: (B: Word); {如果不是, 登记日薪}
    
14. 
    
15. end;
    
16. 
    
17. var
    
18. 
    
19. personRec: TpersonRec;
    
20. 
    
21. begin
    
22. 
    
23. {先算一算这个结构的大小:
    
24. ID 是 Integer 类型, 应该是 4 字节大小;
    
25. A 是 Cardinal 类型, 也应该是 4 字节大小;
    
26. B 是 Word 类型, 应该是 2 字节大小;
    
27. 合计为 10 个字节.
    
28. }
    
29. 
    
30. {可事实, TpersonRec 只有 8 个字节}
    
31. 
    
32. ShowMessage(IntToStr(SizeOf(TpersonRec))); {8}
    
33. 
    
34. {
    
35. 原因是: 字段 A 和 字段 B 公用了一个储存空间;
    
36. 当然这个储存空间得依着大的, 是 Cardinal 的尺寸 4 个字节.
    
37. }
    
38. 
    
39. //赋值测试:
    
40. 
    
41. personRec.ID := 110;
    
42. 
    
43. personRec.A := 100000; {一看就知道是个股东}
    
44. 
    
45. //取值:
    
46. 
    
47. ShowMessage(IntToStr(personRec.A)); {100000; 这不可能有错, 十万大洋}
    
48. 
    
49. //但是:
    
50. 
    
51. ShowMessage(IntToStr(personRec.B)); {34464 ?! 难道这是工人的日薪吗?}
    
52. 
    
53. {
    
54. 首先, A 和 B 两个字段占用同一个空间, 给其中一个赋值, 另一个当然也就有值了;
    
55. 但因为数据类型的容量不同, 它们的值有可能是不一样的.
    
56. 在很多情况下, 我们可能根本不去理会另一个值, 但如果的确需要呢?
    
57. 看下一个例子:
    
58. }
    
59. 
    
60. end;
    
61. 
    
62. 
    
63. 
    
64. type
    
65. 
    
66. TpersonRec = record
    
67. 
    
68. ID: Integer;
    
69. 
    
70. case tag: Boolean of {在这里加了一个 tag 变量}
    
71. 
    
72. True: (A: Cardinal);
    
73. 
    
74. False: (B: Word);
    
75. 
    
76. end;
    
77. 
    
78. var
    
79. 
    
80. personRec: TpersonRec;
    
81. 
    
82. begin
    
83. 
    
84. {我们可以用 tag 变量来区分, 记录中变体部分的值到底是谁的, 譬如:}
    
85. 
    
86. personRec.ID := 110;
    
87. 
    
88. personRec.tag := True;
    
89. 
    
90. personRec.A := 100000; {股东的的年薪}
    
91. 
    
92. personRec.ID := 111;
    
93. 
    
94. personRec.tag := False;
    
95. 
    
96. personRec.B := 100; {工人的日薪}
    
97. 
    
98. end;
    
99. 
    
100. 
     
101. 
     
102. //最经典的变体结构莫过于 Delphi 定义的 TMessage 结构了, 两组数据分分合合都是一体, 多么巧妙啊!
     
103. 
     
104. TMessage = packed record
     
105. 
     
106. Msg: Cardinal;
     
107. 
     
108. case Integer of
     
109. 
     
110. 0: (
     
111. 
     
112. WParam: Longint;
     
113. 
     
114. LParam: Longint;
     
115. 
     
116. Result: Longint);
     
117. 
     
118. 1: (
     
119. 
     
120. WParamLo: Word;
     
121. 
     
122. WParamHi: Word;
     
123. 
     
124. LParamLo: Word;
     
125. 
     
126. LParamHi: Word;
     
127. 
     
128. ResultLo: Word;
     
129. 
     
130. ResultHi: Word);
     
131. 
     
132. end;

复制代码

Records（记录）

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

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

1. type recordTypeName = record
   
2. 
   
3. fieldList1: type1;
   
4. 
   
5. ...
   
6. 
   
7. fieldListn: typen;
   
8. 
   
9. end

复制代码

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

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

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

1. type
   
2. 
   
3. TDateRec = record
   
4. 
   
5. Year: Integer;
   
6. 
   
7. Month: (Jan, Feb, Mar, Apr, May, Jun, Jul, Aug, Sep, Oct, Nov, Dec);
   
8. 
   
9. Day: 1..31;
   
10. 
    
11. end;

复制代码

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

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

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

1. var Record1, Record2: TDateRec;

复制代码

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

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

1. Record1.Year := 1904;
   
2. 
   
3. Record1.Month := Jun;
   
4. 
   
5. Record1.Day := 16;
   
6. 
   
7. //或使用with 语句：
   
8. 
   
9. with Record1 do
   
10. 
    
11. begin
    
12. 
    
13. Year := 1904;
    
14. 
    
15. Month := Jun;
    
16. 
    
17. Day := 16;
    
18. 
    
19. end;

复制代码

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

1. Record2 := Record1;

复制代码

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

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

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

1. var S: record
   
2. 
   
3. Name: string;
   
4. 
   
5. Age: Integer;
   
6. 
   
7. end;

复制代码

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

结构完全相同。

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

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

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

1. type recordTypeName = record
   
2. 
   
3. fieldList1: type1;
   
4. 
   
5. ...
   
6. 
   
7. fieldListn: typen;
   
8. 
   
9. case tag: ordinalType of
   
10. 
    
11. constantList1: (Variant1);
    
12. 
    
13. ...
    
14. 
    
15. constantListn: (Variantn);
    
16. 
    
17. end;

复制代码

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

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

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

ordinalType 表示一种有序类型。

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

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

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

的形式：

1. fieldList1: type1;
   
2. 
   
3. ...
   
4. 
   
5. fieldListn: typen;

复制代码

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

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

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

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

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

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

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

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

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

1. type
   
2. 
   
3. TEmployee = record
   
4. 
   
5. FirstName, LastName: string[40];
   
6. 
   
7. BirthDate: TDate;
   
8. 
   
9. case Salaried: Boolean of
   
10. 
    
11. True: (AnnualSalary: Currency);
    
12. 
    
13. False: (HourlyWage: Currency);
    
14. 
    
15. end;

复制代码

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

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

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

1. type
   
2. 
   
3. TPerson = record
   
4. 
   
5. FirstName, LastName: string[40];
   
6. 
   
7. BirthDate: TDate;
   
8. 
   
9. case Citizen: Boolean of
   
10. 
    
11. True: (Birthplace: string[40]);
    
12. 
    
13. False: (Country: string[20];
    
14. 
    
15. EntryPort: string[20];
    
16. 
    
17. EntryDate, ExitDate: TDate);
    
18. 
    
19. end;
    
20. 
    
21. type
    
22. 
    
23. TShapeList = (Rectangle, Triangle, Circle, Ellipse, Other);
    
24. 
    
25. TFigure = record
    
26. 
    
27. case TShapeList of
    
28. 
    
29. Rectangle: (Height, Width: Real);
    
30. 
    
31. Triangle: (Side1, Side2, Angle: Real);
    
32. 
    
33. Circle: (Radius: Real);
    
34. 
    
35. Ellipse, Other: ();
    
36. 
    
37. end;

复制代码

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

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

了程序员的方便。

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

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

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

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