博客园_泡面 @ 幸福 By Aipeli

Delphi中的容器类

2010-07-13T09:32:00Z

Delphi中的容器类

作者陈省

从Delphi 5开始VCL中增加了一个新的Contnrs单元，单元中定义了８个新的类，全部都是基于标准的TList 类。

TList 类

TList 类实际上就是一个可以存储指针的容器类，提供了一系列的方法和属性来添加，删除，重排，定位，存取和排序容器中的类，它是基于数组的机制来实现的容器，比较类似于C++中的Vector和Java中的ArrayList，TList 经常用来保存一组对象列表，基于数组实现的机制使得用下标存取容器中的对象非常快，但是随着容器中的对象的增多，插入和删除对象速度会直线下降，因此不适合频繁添加和删除对象的应用场景。下面是TList类的属性和方法说明：

属性	描述
Count: Integer;	返回列表中的项目数
Items[Index: Integer]: Pointer; default	通过以０为底的索引下标直接存取列表中的项目

方法	类型	描述
Add(Item: Pointer): Integer;	函数	用来向列表中添加指针
Clear;	过程	清空列表中的项目
Delete(Index: Integer);	过程	删除列表中对应索引的项目
IndexOf(Item: Pointer): Integer;	函数	返回指针在列表中的索引
Insert(Index: Integer; Item: Pointer);	过程	将一个项目插入到列表中的指定位置
Remove(Item: Pointer): Integer;	函数	从列表中删除指针

名称	类型	描述
Capacity: Integer;	property	可以用来获取或设定列表可以容纳的指针数目
Extract(Item: Pointer): Pointer;	function	Extract 类似于Remove 可以将指针从列表中删除，不同的是返回被删除的指针。
Exchange(Index1, Index2: Integer);	procedure	交换列表中两个指针
First: Pointer;	function	返回链表中的第一个指针
Last: Pointer;	function	返回链表中最后一个指针
Move(CurIndex NewIndex: Integer);	procedure	将指针从当前位置移动到新的位置
Pack;	procedure	从列表中删除所有nil指针
Sort(Compare: TListSortCompare);	procedure	用来对链表中的项目进行排序，可以设定Compare参数为用户定制的排序函数

TObjectList 类

TObjectList 类直接从TList 类继承，可以作为对象的容器。TObjectList类定义如下：

TObjectList = class(TList)

...

public

constructor Create; overload;

constructor Create(AOwnsObjects: Boolean); overload;

function Add(AObject: TObject): Integer;

function Remove(AObject: TObject): Integer;

function IndexOf(AObject: TObject): Integer;

function FindInstanceOf(AClass: TClass;

AExact: Boolean = True; AStartAt: Integer = 0):

Integer;

procedure Insert(Index: Integer; AObject: TObject);

property OwnsObjects: Boolean;

property Items[Index: Integer]: TObject; default;

end;

不同于TList类，TObjectList类的Add, Remove, IndexOf, Insert等方法都需要传递TObject对象作为参数，由于有了编译期的强类型检查，使得TObjectList比TList更适合保存对象。此外TObjectList对象有OwnsObjects属性。当设定为True (默认值)，同TList类不同，TObjectList对象将销毁任何从列表中删除的对象。无论是调用Delete, Remove, Clear 方法，还是释放TObjectList对象，都将销毁列表中的对象。有了TObjectList类，我们就再也不用使用循环来释放了对象。这就避免了释放链表对象时，由于忘记释放链表中的对象而导致的内存泄漏。另外要注意的是OwnsObjects属性不会影响到Extract方法，TObjectList的Extract方法行为类似于TList，只是从列表中移除对象引用，而不会销毁对象。

TObjectList 对象还提供了一个FindInstanceOf 函数，可以返回只有指定对象类型的对象实例在列表中的索引。如果AExact 参数为True，只有指定对象类型的对象实例会被定位，如果AExact 对象为False，AClass 的子类实例也将被定位。AStartAt 参数可以用来找到列表中的多个实例，只要每次调用FindInstanceOf 函数时，将起始索引加１，就可以定位到下一个对象，直到FindInstanceOf 返回-1。下面是代码示意：

var

idx: Integer;

begin

idx := -1;

repeat

idx := ObjList.FindInstanceOf(TMyObject, True, idx+1);

if idx >= 0 then

...

until(idx < 0);

end;

TComponentList 类

Contnrs单元中还定义了TComponentList 类，类定义如下：

TComponentList = class(TObjectList)

...

public

function Add(AComponent: TComponent): Integer;

function Remove(AComponent: TComponent): Integer;

function IndexOf(AComponent: TComponent): Integer;

procedure Insert(Index: Integer; AComponent: TComponent);

property Items[Index: Integer]: TComponent; default;

end;

注意TComponentList 是从TObjectList类继承出来的，它的Add, Remove, IndexOf, Insert和 Items 方法调用都使用TComponent 类型的参数而不再是TObject类型，因此适合作为TComponent对象的容器。TComponentList 类还有一个特殊的特性，就是如果链表中的一个组件被释放的话，它将被自动的从TComponentList 链表中删除。这是利用TComponent的FreeNotification方法可以在组件被销毁时通知链表，这样链表就可以将对象引用从链表中删除的。

TClassList 类

Contnrs单元中还定义了TClassList类，类定义如下：

TClassList = class(TList)

protected

function GetItems(Index: Integer): TClass;

procedure SetItems(Index: Integer; AClass: TClass);

public

function Add(aClass: TClass): Integer;

function Remove(aClass: TClass): Integer;

function IndexOf(aClass: TClass): Integer;

procedure Insert(Index: Integer; aClass: TClass);

property Items[Index: Integer]: TClass

read GetItems write SetItems; default;

end;

不同于前面两个类，这个类继承于TList的类只是将Add, Remove, IndexOf, Insert和Items 调用的参数从指针换成了TClass元类类型。

TOrderedList, TStack和TQueue 类

Contnrs单元还定义了其它三个类：TOrderedList, TStack和TQueue，类型定义如下：

TOrderedList = class(TObject)

private

FList: TList;

protected

procedure PushItem(AItem: Pointer); virtual; abstract;

...

public

function Count: Integer;

function AtLeast(ACount: Integer): Boolean;

procedure Push(AItem: Pointer);

function Pop: Pointer;

function Peek: Pointer;

end;

TStack = class(TOrderedList)

protected

procedure PushItem(AItem: Pointer); override;

end;

TQueue = class(TOrderedList)

protected

procedure PushItem(AItem: Pointer); override;

end;

要注意虽然TOrderedList 并不是从TList继承的，但是它在内部的实现时，使用了TList来储存指针。另外注意TOrderedList类的PushItem 过程是一个抽象过程，所以我们无法实例化 TOrderedList 类，而应该从TOrderedList继承新的类，并实现抽象的PushItem方法。TStack 和 TQueue 正是实现了PushItem抽象方法的类，我们可以实例化TStack 和TQueue类作为后进先出的堆栈 (LIFO)和先进先出的队列(FIFO)。下面是这两个的的方法使用说明：　

· Count 返回列表中的项目数。

· AtLeast 可以用来检查链表的大小，判断当前列表中的指针数目是否大于传递的参数值，如果为True表示列表中的项目数大于传来的参数。　

· 对于TStack类Push 方法将指针添加到链表的最后，对于TQueue类Push 方法则将指针插入到链表的开始。

· Pop返回链表的末端指针，并将其从链表中删除。　

· Peek返回链表的末端指针，但是不将其从链表中删除。　

TObjectStack和TObjectQueue类

Contnrs单元中最后两个类是TObjectStack和TObjectQueue类，类的定义如下：

TObjectStack = class(TStack)

public

procedure Push(AObject: TObject);

function Pop: TObject;

function Peek: TObject;

end;

TObjectQueue = class(TQueue)

public

procedure Push(AObject: TObject);

function Pop: TObject;

function Peek: TObject;

end;

这两个类只是TStack和TQueue 类的简单扩展，在链表中保存的是TObject的对象引用，而不是简单的指针。

TIntList 类

到目前为止，我们看到的容器类中保存的都是指针或者对象引用（对象引用其实也是一种指针）。

那么我们能不能在链表中保存原生类型，如Integer，Boolean或者Double等呢。下面的我们定义的类TIntList 类就可以在链表中保存整数，这里我们利用了整数和指针都占用４个字节的存储空间，所以我们可以直接将指针映射为整数。

unit IntList;

interface

uses

Classes;

type

TIntList = class(TList)

protected

function GetItem(Index: Integer): Integer;

procedure SetItem(Index: Integer;

const Value: Integer);

public

function Add(Item: Integer): Integer;

function Extract(Item: Integer): Integer;

function First: Integer;

function IndexOf(Item: Integer): Integer;

procedure Insert(Index, Item: Integer);

function Last: Integer;

function Remove(Item: Integer): Integer;

procedure Sort;

property Items[Index: Integer]: Integer

read GetItem write SetItem; default;

end;

implementation

{ TIntList }

function TIntList.Add(Item: Integer): Integer;

begin

Result := inherited Add(Pointer(Item));

end;

function TIntList.Extract(Item: Integer): Integer;

begin

Result := Integer(inherited Extract(Pointer(Item)));

end;

function TIntList.First: Integer;

begin

Result := Integer(inherited First);

end;

function TIntList.GetItem(Index: Integer): Integer;

begin

Result := Integer(inherited Items[Index]);

end;

function TIntList.IndexOf(Item: Integer): Integer;

begin

Result := inherited IndexOf(Pointer(Item));

end;

procedure TIntList.Insert(Index, Item: Integer);

begin

inherited Insert(Index, Pointer(Item));

end;

function TIntList.Last: Integer;

begin

Result := Integer(inherited Last);

end;

function TIntList.Remove(Item: Integer): Integer;

begin

Result := inherited Remove(Pointer(Item));

end;

procedure TIntList.SetItem(Index: Integer;

const Value: Integer);

begin

inherited Items[Index] := Pointer(Value);

end;

function IntListCompare(Item1, Item2: Pointer): Integer;

begin

if Integer(Item1) < Integer(Item2) then

Result := -1

else if Integer(Item1) > Integer(Item2) then

Result := 1

else

Result := 0;

end;

procedure TIntList.Sort;

begin

inherited Sort(IntListCompare);

end;

end.

扩展TList，限制类型的对象列表

Begin Listing Two - TMyObjectList

TMyObject = class(TObject)

public

procedure DoSomething;

end;

TMyObjectList = class(TObjectList)

protected

function GetItems(Index: Integer): TMyObject;

procedure SetItems(Index: Integer; AMyObject: TMyObject);

public

function Add(aMyObject: TMyObject): Integer;

procedure DoSomething;

function Remove(aMyObject: TMyObject): Integer;

function IndexOf(aMyObject: TMyObject): Integer;

procedure Insert(Index: Integer; aMyObject: TMyObject);

property Items[Index: Integer]: TMyObject

read GetItems write SetItems; default;

end;

...

{ TMyObjectList }

function TMyObjectList.Add(AMyObject: TMyObject): Integer;

begin

Result := inherited Add(AMyObject);

end;

procedure TMyObjectList.DoSomething;

var

i: Integer;

begin

for i := 0 to Count-1 do

Items[i].DoSomething;

end;

function TMyObjectList.GetItems(Index: Integer): TMyObject;

begin

Result := TMyObject(inherited Items[Index]);

end;

function TMyObjectList.IndexOf(AMyObject: TMyObject):

Integer;

begin

Result := inherited IndexOf(AMyObject);

end;

procedure TMyObjectList.Insert(Index: Integer;

AMyObject: TMyObject);

begin

inherited Insert(Index, AMyObject);

end;

function TMyObjectList.Remove(AMyObject: TMyObject):

Integer;

begin

Result := inherited Remove(AMyObject);

end;

procedure TMyObjectList.SetItems(Index: Integer;

AMyObject: TMyObject);

begin

inherited Items[Index] := AMyObject;

end;

End Listing Two

TStrings类

出于效率的考虑，Delphi并没有象C++和Java那样将字符串定义为类，因此TList本身不能直接存储字符串，而字符串列表又是使用非常广泛的，为此Borland提供了TStrings类作为存储字符串的基类，应该说是它除了TList类之外另外一个最重要的Delphi容器类。

要注意的是TStrings类本身包含了很多抽象的纯虚的方法，因此不能实例化后直接使用，必须从TStrings类继承一个基类实现所有的抽象的纯虚方法来进行实际的字符串列表管理。虽然TStrings类本身是一个抽象类，但是它应该说是一个使用了Template模式的模版类，提供了很多事先定义好的算法来实现添加添加、删除列表中的字符串，按下标存取列表中的字符串，对列表中的字符串进行排序，将字符串保存到流中。将每个字符串同一个对象关联起来，提供了键-值对的关联等等。

因为TStrings类本身是个抽象类，无法实例化，因此Delphi提供了一个TStringList的TStrings的子类提供了TStrings类的默认实现，通常在实际使用中，我们都应该使用TStringList类存储字符串列表，代码示意如下：

var TempList: TStrings;

begin

TempList := TStringList.Create;

try

TempList.Add(‘字符串1’);

…

finally

TempList.Free;

end;

TStrings类的应用非常广泛，很多VCL类的属性都是TStrings类型，比如TMemo组件的Lines属性，TListBox的Items属性等等。下面将介绍一下TStrings类的常见用法。

TStrings类的常见的用法

根据下标存取列表中的字符串是最常见的一种操作，用法示意如下：

StringList1.Strings[0] := '字符串1';

注意在Delphi中，几乎所有的列表的下标都是以0为底的，也就是说Strings[0]是列表中的第一个字符串。另外，由于Strings属性是字符串列表类的默认属性，因此可以省略Strings，直接用下面的简便方法存取字符串：

StringList1[0] := '字符串1';

定位一个列表中特定的字符串的位置，可以使用IndexOf方法，IndexOf方法将会返回在字符串列表中的第一个匹配的字符串的索引值，如果没有匹配的字符串则返回-1。比如我们可以使用IndexOf方法来察看特定文件是否存在于文件列表框中，代码示意如下：

if FileListBox1.Items.IndexOf('TargetFileName') > -1 ...

有一点不方便的是TStrings类没有提供一个方法可以查找除了第一个匹配字符串外其他同样匹配的字符串的索引，只能是自己遍历字符串列表来实现，这点不如C++中的模版容器类以及相关的模版算法强大和方便。下面是一个遍历字符串列表的示意，代码遍历列表框中的所有字符串，并将其全部转化为大写的字符串：

procedure TForm1.Button1Click(Sender: TObject);var Index: Integer;

begin

for Index := 0 to ListBox1.Items.Count - 1 do

ListBox1.Items[Index] := UpperCase(ListBox1.Items[Index]);

end;

前面我们看到了，要想向字符串列表中添加字符串，直接使用Add方法就可以了，但是Add方法只能将字符串加入到列表的末尾，要想在列表的指定位置添加字符串，需要使用Insert方法，下面代码在列表的索引为2的位置添加了字符串：

StringList1.Insert(2, 'Three');

如果要想将一个字符串列表中的所有字符串都添加到另一个字符串列表中，可以使用AddStrings方法，用法如下:

StringList1.AddStrings(StringList2);

要想克隆一个字符串列表的所有内容，可以使用Assign方法，例如下面的方法将Combox1中的字符串列表复制到了Memo1中：

Memo1.Lines.Assign(ComboBox1.Items);

要注意的是使用了Assign方法后，目标字符串列表中原有的字符串会全部丢失。

同对象关联

前面说了我们可以将字符串同对象绑定起来，我们可以使用AddObject或者InsertObject方法向列表添加同字符串关联的对象，也可以通过Objects属性直接将对象同特定位置的字符串关联。此外TStrings类还提供了IndexOfObject方法返回指定对象的索引，同样的Delete,Clear和Move等方法也可以作用于对象。不过要注意的是我们不能向字符串中添加一个没有同字符串关联的对象。

同视图交互

刚刚学习使用Delphi的人都会为Delphi IDE的强大的界面交互设计功能所震惊，比如我们在窗体上放上一个ListBox，然后在object Inspector中双击它的Items属性（TStrings类型），在弹出的对话框中，见下图，我们输入一些字符串后，点击确定，关闭对话框，就会看到窗体上的ListBox中出现了我们刚才输入的字符串。

可以我们在TStrings和默认的实现类TStringList的源代码中却找不到同ListBox相关的代码，那么这种界面交互是如何做到的呢？

秘密就在于TListBox的Items属性类型实际上是TStrings的基类TListBoxStrings类，我们看一下这个类的定义：

TListBoxStrings = class(TStrings)

private

ListBox: TCustomListBox;

protected

…

public

function Add(const S: string): Integer; override;

procedure Clear; override;

procedure Delete(Index: Integer); override;

procedure Exchange(Index1, Index2: Integer); override;

function IndexOf(const S: string): Integer; override;

procedure Insert(Index: Integer; const S: string); override;

procedure Move(CurIndex, NewIndex: Integer); override;

end;

可以看到TListBoxStrings类实现了TStrings类的所有抽象方法，同时在内部有一个ListBox的私有变量。我们再看一下TListBoxStrings的Add方法：

function TListBoxStrings.Add(const S: string): Integer;

begin

Result := -1;

if ListBox.Style in [lbVirtual, lbVirtualOwnerDraw] then exit;

Result := SendMessage(ListBox.Handle, LB_ADDSTRING, 0, Longint(PChar(S)));

if Result < 0 then raise EOutOfResources.Create(SInsertLineError);

end;

可以看到TListBoxStrings在内部并没有保存添加的字符串，而是直接向Windows的原生列表盒控件发送消息实现的代码添加，而Windows的原生列表盒是一个MVC的组件，当内部的数据发生变化时，会自动改变视图显示，这就是为什么我们在设计器中输入的字符串会立刻显示在窗体列表框中的原因了。

于是我们也就知道为什么Borland将TStrings设计为一个抽象的类而没有提供一个默认的存储方式，就是因为很多的界面组件在内部对数据的存储有很多不同的方式，Borland决定针对不同的组件提供不同的存储和交互方式。同样的我们要编写的组件如果有TStrings类型的属性，同时也要同界面或者其它资源交互的话，不要使用TStringList来实现，而应该从TStrings派生出新类来实现更好的交互设计。

还有一点要说明的是，Delphi的IDE只在使用Delphi的流机制保存组件到窗体设计文件DFM文件中的时，做了一些特殊的处理，能够自动保存和加载Published的TStrings类型的属性，下面就是一个ListBox储存在窗体设计文件DFM中文本形式示意(在窗体设计阶段，我们可以直接使用View As Text右键菜单命令看到下面的文本)，我们可以注意到在设计时我们输入的Items的两个字符串被保存了起来：

object ListBox1: TListBox

Left = 64

Top = 40

Width = 145

Height = 73

ItemHeight = 16

Items.Strings = (

'String1'

'String2')

TabOrder = 1

end

随后如果运行程序时，VCL库会使用流从编译进可执行文件的DFM资源中将Items.Strings列表加载到界面上，这样就实现了设计是什么样，运行时也是什么样的所见即所得。

键-值对

在实际开发过程中，我们经常会碰到类似于字典的定位操作的通过键查找相应值的操作，比如通过用户名查找用户相应的登陆密码等。在C++和Java中，标准模版库和JDK都提供了Map类来实现键-值机制，但是Delphi的VCL库却没有提供这样的类，但是TStrings类提供了一个简易的Map替代的实现，那就是Name-Value对。

对于TStrings来说，所谓的Name-Value对，实际上就是’Key=Value’这样包含＝号的分割的字符串，等号左边的部分就是Name，等号右边的部分就是Value。TStrings类提供了IndexOfName和Values等属性方法来操作Name-Value对。下面是用法示意：

var

StringList1:TStrings;

Begin

StringList1:=TStringList.Create;

//添加用户名-密码对

StringList1.Add(‘hubdog=aaa’);

StringList1.Add(‘hubcat=bbb’);

….

//根据用户名hubdog查找密码

Showmessage(StringList1.Values[StringList1.IndexOfName(‘hubdog’)]);

End;

从Delphi7开始，TStrings类增加了一个NameValueSeparator属性，我们可以通过这个属性修改默认的Name-Value分割符号为=号以外的其它符号了。还要说明的是，TStrings的Name-Value对中的Name可以不唯一，这有点类似于C++中的MultiMap，这时通过Values[Names[IndexOfName]]下标操作取到的值不一定是我们所需要的，另外TStrings类的Name-Value对的查找定位是采用的遍历的方式，而不同于Java和C++中的Map是基于哈希表或者树的实现，因此查找和定位的效率非常低，不适用于性能要求非常高的场景。不过从Delphi6开始,VCL库中在IniFiles单元中提供了一个基于哈希表的字符串列表类THashedStringList类可以极大的提高查找定位的速度。

THashedStringList类

一般来说，通过键来查找值最简单的办法是遍历列表对列表中的键进行比较，如果相等则获取相应的键值。但是这种简单的办法也是效率最差的一种办法，当列表中的项目比较少时，这种办法还可以接受，但是如果列表中项目非常多的话，这种方法会极大的影响软件的运行速度。这时我们可以使用哈希表来快速的通过键值来存取列表中的元素。由于本书并不是一本数据结构和算法的书，因此我无意在这里讨论哈希表背后的理论知识，我们只要知道哈希可以通过键快速定位相应的值就可以了，对此感兴趣的非计算机专业的人可以去察看相关的书，这里就不赘述了。

Delphi6中提供的THashedStringList类没有提供任何的新的方法，只是对IndexOf和IndexOfName函数通过哈希表进行了性能优化，下面这个例子演示了TStringList和THashedStringList之间的性能差异：

unit CHash;

interface

uses

Windows, Messages, SysUtils, Variants, Classes, Graphics, Controls, Forms,

Dialogs, StdCtrls, Inifiles;

type

TForm1 = class(TForm)

Button1: TButton;

procedure Button1Click(Sender: TObject);

procedure FormCreate(Sender: TObject);

procedure FormDestroy(Sender: TObject);

private

{ Private declarations }

HashedList: THashedStringList;

DesList: TStringList;

List: TStringList;

public

{ Public declarations }

procedure Hash;

procedure Iterate;

end;

var

Form1: TForm1;

implementation

{$R *.dfm}

procedure TForm1.Button1Click(Sender: TObject);

var

I:Integer;

begin

Screen.Cursor := crHourGlass;

try

//初始化系统

for I := 0 to 5000 do

begin

HashedList.Add(IntToStr(i));

List.Add(IntToStr(i));

end;

Hash;

DesList.Clear;

Iterate;

finally

Screen.Cursor := crDefault;

end;

procedure TForm1.Hash;

var

I, J: Integer;

begin

//基于哈希表的定位

for I := 3000 to 4000 do

begin

DesList.Add(IntToStr(HashedList.IndexOf(IntToStr(I))));

end;

procedure TForm1.Iterate;

var

I, J: Integer;

begin

//基于遍历方式定位

for I := 3000 to 4000 do

begin

DesList.Add(IntToStr(List.IndexOf(IntToStr(I))));

end;

procedure TForm1.FormCreate(Sender: TObject);

begin

HashedList := THashedStringList.Create;

DesList := TStringList.Create;

List := TStringList.Create;

end;

procedure TForm1.FormDestroy(Sender: TObject);

begin

HashedList.Free;

DesList.Free;

List.Free;

end;

end.

上面代码中的Hash过程，采用了新的THashedStringList类来实现的查找，而Iterate过程中使用了原来的TStringList类的IndexOfName来实现的查找。采用GpProfile（注：GpProfile的用法参见工具篇的性能分析工具GpProfile章节）对两个过程进行了性能比较后，从下图可以看到Hash执行同样查找动作只用了0.7%的时间，而Iterate方法则用了99.3%的时间，可以看到在字符串列表项目数在几千的数量级别时，基于哈希表的查询速度是原有方法的100多倍。

不过要说明的是，THashedStringList同TStringList类相比，虽然查找的速度大大提高了，但是在添加、删除字符串后再次进行查找操作时，需要重新计算哈希函数，所以如果频繁的进行删除或者添加同查找的复合操作，执行的速度很有可能比TStringList还要慢，这是使用时需要注意的。

TBucketList和TObjectBucketList类

从Delphi6开始，VCL的Contnrs单元中又增加了两个新的容器类TBucketList和TObjectBucketList。TBucketList实际上也是一个简单基于哈希表的指针-指针对列表。接口定义如下：

TBucketList = class(TCustomBucketList)

…

public

destructor Destroy; override;

procedure Clear;

function Add(AItem, AData: Pointer): Pointer;

function Remove(AItem: Pointer): Pointer;

function ForEach(AProc: TBucketProc; AInfo: Pointer = nil): Boolean;

procedure Assign(AList: TCustomBucketList);

function Exists(AItem: Pointer): Boolean;

function Find(AItem: Pointer; out AData: Pointer): Boolean;

property Data[AItem: Pointer]: Pointer read GetData write SetData; default;

end;

类的Add方法现在接受两个参数AItem和AData，我们可以把它看成是指针版的Map实现（从容器类来看, Delphi从语言的灵活性来说不如C++，为了实现不同类型的哈希Map容器，Delphi需要派生很多的类，而C++的Map是基于模版技术来实现的，容器元素的类型只要简单的声明一下就能指定了，使用起来非常方便。而从简单性来说，则不如Java的容器类，因为Delphi中的String是原生类型，而不是类，并且Delphi还提供对指针的支持，因此要为指针和字符串提供不同的Map派生类），类中的Exists和Find等方法都是通过哈希表来实现快速数据定位的。同时,同一般的列表容器类不同，TBucketList不提供通过整数下标获取列表中的元素的功能，不过我们可以使用ForEach方法来遍历容器内的元素。

TObjectBucketList是从TBucketList派生的基类，没有增加任何新的功能，唯一的不同之处就是容器内的元素不是指针而是对象了，实现了更强的类型检查而已。

其它容器类

TThreadList类

TThreadList类实际上就是一个线程安全的TList类，每次添加或者删除容易中指针时，TThreadList会调用EnterCriticalSection函数进入线程阻塞状态，这时其它后续发生的对列表的操作都会阻塞在那里，直到TThreadList调用UnLockList释放对列表的控制后才会被依次执行。在多线程开发中，我们需要使用TThreadList来保存共享的资源以避免多线程造成的混乱和冲突。还要注意的是TThreadList有一个Duplicates布尔属性，默认为True，表示列表中不能有重复的指针。设定为False将允许容器内有重复的元素。

TInterfaceList类

在Classes单元中，VCL还定义了一个可以保存接口的列表类。我们可以向列表中添加接口类型，这个类的操作方法同其它的列表类没有什么区别，只不过在内部使用TThreadList作为容器实现了线程安全。

拟容器类TBits类

在Classes.pas还有一个特殊的TBits类，接口定义如下：

TBits = class

…

public

destructor Destroy; override;

function OpenBit: Integer;

property Bits[Index: Integer]: Boolean read GetBit write SetBit; default;

property Size: Integer read FSize write SetSize;

end;

它可以按位储存布尔值，因此可以看成是一个原生的Boolean值的容器类，但是它缺少列表类的很多方法和特性，不能算是一个完整的容器，因此我们称它为拟容器类。

在我们开发过程中，经常需要表示一些类似于开关的二元状态，这时我们用TBits来表示一组二元状态非常方便，同时TBits类的成员函数主要是用汇编语言写的，位操作的速度非常快。二元状态组的大小通过设定TBits类的Size属性来动态的调整，存取Boolean值可以通过下标来存取TBits类的Bits属性来实现。至于OpenBit函数，它返回第一个不为True的Boolean值的下标。从接口定义可以看出，TBits类接口非常简单，提供的功能也很有限，我猜测这只是Borland的研发队伍满足内部开发有限需要的类，并不是作为一个通用类来设计的，比如它没有开放内部数据存取的接口，无法获得内部数据的表达，进而无法实现对状态的保存和加载等更高的需求。

TCollection类

前面我们提到了Delphi的IDE能够自动将字符串列表保存在DFM文件中，并能在运行时将设计期编辑的字符串列表加载进内存（也就是我们通常所说的类的可持续性）。TStrings这种特性比较适合于保存一个对象同多个字符串数据之间关联，比较类似于现实生活中一个人同多个Email账户地址之间的关系。但是，TStrings类型的属性有一个很大的局限那就是，它只能用于设计时保存简单的字符串列表，而不能保存复杂对象列表。而一个父对象同多个子对象之间的聚合关系可能更为常见，比如一列火车可能有好多节车厢构成，每节车厢都有车厢号，车厢类型（卧铺，还是硬座），车厢座位数，车厢服务员名称等属性构成。如果我们想在设计期实现对火车的车厢定制的功能，并能保存车厢的各个属性到窗体文件中，则车厢集合属性定义为TStrings类型的属性是行不通的。

对于这个问题，Delphi提供了TCollection容器类属性这样一个解决方案。TCollection以及它的容器元素TCollectionItem的接口定义如下：

TCollection = class(TPersistent)

…

protected

procedure Added(var Item: TCollectionItem); virtual; deprecated;

procedure Deleting(Item: TCollectionItem); virtual; deprecated;

property NextID: Integer read FNextID;

procedure Notify(Item: TCollectionItem; Action: TCollectionNotification); virtual;

{ Design-time editor support }

function GetAttrCount: Integer; dynamic;

function GetAttr(Index: Integer): string; dynamic;

function GetItemAttr(Index, ItemIndex: Integer): string; dynamic;

procedure Changed;

function GetItem(Index: Integer): TCollectionItem;

procedure SetItem(Index: Integer; Value: TCollectionItem);

procedure SetItemName(Item: TCollectionItem); virtual;

procedure Update(Item: TCollectionItem); virtual;

property PropName: string read GetPropName write FPropName;

property UpdateCount: Integer read FUpdateCount;

public

constructor Create(ItemClass: TCollectionItemClass);

destructor Destroy; override;

function Owner: TPersistent;

function Add: TCollectionItem;

procedure Assign(Source: TPersistent); override;

procedure BeginUpdate; virtual;

procedure Clear;

procedure Delete(Index: Integer);

procedure EndUpdate; virtual;

function FindItemID(ID: Integer): TCollectionItem;

function GetNamePath: string; override;

function Insert(Index: Integer): TCollectionItem;

property Count: Integer read GetCount;

property ItemClass: TCollectionItemClass read FItemClass;

property Items[Index: Integer]: TCollectionItem read GetItem write SetItem;

end;

TCollectionItem = class(TPersistent)

…

protected

procedure Changed(AllItems: Boolean);

function GetOwner: TPersistent; override;

function GetDisplayName: string; virtual;

procedure SetCollection(Value: TCollection); virtual;

procedure SetIndex(Value: Integer); virtual;

procedure SetDisplayName(const Value: string); virtual;

public

constructor Create(Collection: TCollection); virtual;

destructor Destroy; override;

function GetNamePath: string; override;

property Collection: TCollection read FCollection write SetCollection;

property ID: Integer read FID;

property Index: Integer read GetIndex write SetIndex;

property DisplayName: string read GetDisplayName write SetDisplayName;

end;

TCollection类是一个比较复杂特殊的容器类。但是初看上去，它就是一个TCollectionItem对象的容器类，同列表类TList类似，TCollection类也维护一个TCollectionItem对象索引数组，Count属性表示容器中包含的TCollectionItem的数目，同时也提供了Add和Delete方法来添加和删除TCollectionItem对象以及通过下标存取TCollectionItem的属性。看上去和容器类区别不大，但是在VCL内部用于保存和加载组件的TReader和TWriter类提供了两个特殊的方法WriteCollection和ReadCollection用于加载和保存TCollection类型的集合属性。IDE就是通过这两个方法实现对TCollection类型属性的可持续性。

假设现在需要设计一个火车组件TTrain，TTrain组件有一个TCollection类型的属性Carriages表示多节车厢构成的集合属性，每个车厢则对应于集合属性的元素，从TCollectionItem类继承，有车厢号，车厢类型（卧铺，还是硬座），车厢座位数，车厢服务员名称等属性，下面是我设计的组件的接口：

type

//车厢类型，硬座、卧铺

TCarriageType = (ctHard, ctSleeper);

//车厢类

TCarriageCollectionItem = class(TCollectionItem)

…

published

//车厢号码

property CarriageNum: Integer read FCarriageNum write FCarriageNum;

//座位数

property SeatCount: Integer read FSeatCount write FSeatCount;

//车厢类型

property CarriageType: TCarriageType read FCarriageType write FCarriageType;

//服务员名称

property ServerName: string read FServerName write FServerName;

end;

TTrain=class;

//车厢容器属性类

TCarriageCollection = class(TCollection)

private

FTrain:TTrain;

function GetItem(Index: Integer): TCarriageCollectionItem;

procedure SetItem(Index: Integer; const Value: TCarriageCollectionItem);

protected

function GetOwner: TPersistent; override;

public

constructor Create(ATrain: TTrain);

function Add: TCarriageCollectionItem;

property Items[Index: Integer]: TCarriageCollectionItem read GetItem

write SetItem; default;

end;

//火车类

TTrain = class(TComponent)

private

FItems: TCarriageCollection;

procedure SetItems(Value: TCarriageCollection);

public

constructor Create(AOwner: TComponent); override;

destructor Destroy; override;

published

property Carriages: TCarriageCollection read FItems write SetItems;

end;

其中车厢类的定义非常简单，只是定义了四个属性。而车厢集合类重定义了静态的Add方法以及Items属性，其返回结果类型改为了TCarriageCollectionItem，下面是车厢集合类的实现代码：

function TCarriageCollection.Add: TCarriageCollectionItem;

begin

Result:=TCarriageCollectionItem(inherited Add);

end;

constructor TCarriageCollection.Create(ATrain: TTrain);

begin

inherited Create(TCarriageCollectionItem);

FTrain:=ATrain;

end;

function TCarriageCollection.GetItem(

Index: Integer): TCarriageCollectionItem;

begin

Result := TCarriageCollectionItem(inherited GetItem(Index));

end;

function TCarriageCollection.GetOwner: TPersistent;

begin

Result:=FTrain;

end;

procedure TCarriageCollection.SetItem(Index: Integer;

const Value: TCarriageCollectionItem);

begin

inherited SetItem(Index, Value);

end;

其中Add,GetItem和SetItem都非常简单，就是调用基类的方法，然后将基类的方法的返回结果重新映射为TCollectionItem类型。而构造函数中将TTrain组件作为父组件传入，并重载GetOwner方法，返回TTrain组件，这样处理的原因是IDE会在保存集合属性时调用集合类的GetOwner确认属性的父控件是谁，这样才能把集合属性写到DFM文件中时，才能存放到正确的位置下面，建立正确的聚合关系。

而火车组件的实现也非常简单，只要定义一个Published Carriages属性就可以了，方法实现代码如下：

constructor TTrain.Create(AOwner: TComponent);

begin

inherited;

FItems := TCarriageCollection.Create(Self);

end;

destructor TTrain.Destroy;

begin

FItems.Free;

inherited;

end;

procedure TTrain.SetItems(Value: TCarriageCollection);

begin

FItems.Assign(Value);

end;

下面将我们的组件注册到系统面板上之后，就可以在窗体上放上一个TTrain组件，然后然后选中Object Inspector，然后双击Carriages属性，会显示系统默认的集合属性编辑器，使用Add按钮向列表中添加两个车厢，修改一下属性，如下图所示意：

从上面的属性编辑器我们，可以看到默认情况下，属性编辑器列表框是按项目索引加上一个横杠来显示车厢的名称，看起来不是很自然。要想修改显示字符串，需要重载TCarriageCollectionItem的GetDisplayName方法。修改后的GetDisplayName方法显示车厢加车厢号码：

function TCarriageCollectionItem.GetDisplayName: string;

begin

Result:='车厢'+IntToStr(CarriageNum);

end;

示意图：

保存一下文件，使用View As Text右键菜单命令察看一下DFM文件，我们会看到我们设计的车厢类的属性确实都被写到了DFM文件中，并且Carriages属性的父亲就是Train1：

object Train1: TTrain

Carriages = <

item

CarriageNum = 1

SeatCount = 100

CarriageType = ctHard

ServerName = '陈省'

end

item

CarriageNum = 2

SeatCount = 200

CarriageType = ctHard

ServerName = 'hubdog'

end>

Left = 16

Top = 8

End

TOwnedCollection

从Delphi4开始，VCL增加了一个TOwnedCollection类，它是TCollection类的子类，如果我们的TCarriageCollection类是从TOwnedCollection类继承的，这时我们就不再需要向上面重载GetOwner方法并返回父控件给IDE，以便TCarriageCollection属性能出现在Object Inspector中了。

总结

本章中我介绍了几乎所有VCL中重要的容器类，其中TList及其子类相当于通用的容器类，虽然不如C++和Java功能那么强大，但是用好了已经足以满足我们90%的开发需要，而TStrings及其子类，还有TCollection则是实现所见即所得设计的关键类，对于开发灵活强大的自定义组件来说是必不可少的。

本文链接

[转]Delphi中record的使用

2010-07-03T09:50:00Z

在Delphi中的Record类型中，与之C语言对应的即是结构体类型（struct），也可能是为了符合C语言或C++程序员的习惯，对于它在Delphi中的应用存在的一些问题进行初步的说明。在Delphi中的记录体类型有两种方式定义

Type

RecTest = record (packed)

ID :integer;

Name :string;

Descript:string;

end;

之两种类型的主要区别在于在内存中的存放，Packed是紧缩类型的,可以节省内存空间与存放的空间，但是它定义好了对应的长度，所以不太适合存放不定长的数据，如string类型的数据；同时在使用记录体类型时特别要注意的是使用记录体数组的情况，使用不当不仅仅会出现性能方面的问题，同时也会产生意想不到的错误。如 RecList arrary[0..100] of RecTest，如采用这样的定义的方面，会产生的问题有：

1.当用数组下标访问对应的记录体元素时，到后面的数据记录访问时间会越来越长，如RecList[89] ,它需要将RecTest中移动88个记录长度，由于RecTest是不定长的，所以每次移动的长度也可能不相同，所以导致定位数组中记录体时定位时间长

2.当对记录体进行赋值时，如果想默认或遗忘给某个变量赋值，则会产生比较严重的后果，当应用到该变量时，可能会读取到错误的数值

如一定要使用记录体类型的，可以采用一些变通的方法，如采用数组指针，这样可以大幅提升性能，如针对前面的记录体数据情况，可以多定义一个指针变量，如下： PRecList = ^RecTest

RecList arrary[0..100] of PRecList

这样定义相对的好处就是每次移动时，只需要移动记录指针的长度数即可，即在现有的windows系统中，只需要移动4位即可。

所以针对上面的问题，在程序开发中尽量少采用记录体类型，直接定义一个相应的类即可，定义一个相应的类处理的好处时，可以与面对对象的开发的方法相一致，只不过是比记录体多了创建与释放而已，但相应的初始化或方法、属性在类中很容易实现，同时对于程序的扩展类也很容易处理，记录体可能会比较麻烦，如在记录体中增加一个字段，那有可能整个程序都需要变化，但在对象中增加一个属性会显得非常方便，同时也容易对于对象中的属性内容进行初始化处理。

另：在对不定长记录进行再分配空间时，如增加一个长度的空间，在系统中的处理是先开避一块内存地址保存当前内容再在此基础上加一个长度的地址长度，即在相应的内存中需要复制两个长度的地址后才能完成增加长度。

补充1:

1. 首先了解到record是可以限制field的范围的，而且定义枚举类型的。

type TDateRec = record

Year: Integer;

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

Day: 1..31;

end;

2. 可以在不定义结构体的情况下，直接在变量声明时使用。

var S: record

Name: string;

Age: Integer;

end;

3. 下面是变体部分，这是Delphi中变体在结构中的标准定义

type recordTypeName = record

fieldList1: type1;

...

fieldListn: typen;

case tag: ordinalType of

constantList1: (variant1);

...

constantListn: (variantn);

end;

Ø Tag可以省略

Ø constantList的类型和ordinalType的类型一致

Ø fieldList的类型不能是long strings, dynamic arrays, variants，也不能是包含这些的结构体，但可以是指向这些类型的指针

Ø Tag和constantLists 在编译器处理这些字段时没有用，只是为程序员理解时提供方便（原文：The optional tag and the constantLists play no role in the way the compiler manages the fields; they are there only for the convenience of the programmer.）

Ø 使用变体结构体的两个原因：一个是需要不同的数据，但是又不会同时需要所有的字段。

type TEmployee = record

FirstName, LastName: string[40];

BirthDate: TDate;

case Salaried: Boolean of

True: (AnnualSalary: Currency);

False: (HourlyWage: Currency);

end;

Ø 另一个原因是可以把同样的数据就像是不同的类型的数据。比如，你有一个64位的实数做为第一个字段，你就可以把它的高32位作为整数返回。这是Delphi帮助里说的。不太好看出来，而且Real到Interger的转换我也很少用。弄个Word到Byte的结构到时很常用。

Type

RConversion = record

Case Boolean of

True : (aWord: Word;);

False : (abyte bbyte : Byte;);

end;

这里附加一句观点，我和周围的同事认为这样的结构体会造成代码的易读性降低，一般在自己的代码中不建议使用，当然为兼容Windows的一些结构除外，他本来就是union当然用这样的直接套用就可以了。

结构体的基本应用就是这样的。还有一些特殊的应用，比如“class-like”的结构体，和file of record。

Class-like的结构体我不知道什么时候使用，既然需要Create，用类不就得了。下面有篇文章对原理有一些阐述http://blog.csdn.net/maozefa/archive/2007/08/27/1760612.aspx。

File of record，个人比较喜欢，特别是在记录某种数据的时候，经常是把一个结构体整个写入到文件里，既实现了一定程度的加密，又简单方便，读出来也可以直接放进结构体里。这里就不详细描述了。

补充2:

delphi语言在传统的Records类型的基础上增加了许多像类一样的高级功能，如：Records可以有属性和方法（包括构造constructors），类属性，类方法，类静态字段和内嵌类型。下面这个示例演示定义一个功能像类一样的Records：
type
TMyRecord = record
    type
      TInnerColorType = Integer;
    var
      Red: Integer;
    class var
      Blue: Integer;
    procedure printRed();
    constructor Create(val: Integer);
    property RedProperty: TInnerColorType read Red write Red;
    class property BlueProp: TInnerColorType read Blue write Blue;
end;

constructor TMyRecord.Create(val: Integer);
begin
Red := val;
end;

procedure TMyRecord.printRed;
begin
writeln('Red: ', Red);
end;
虽然现在records能实现许多类的特性，但它与类之间还是有一些不同：
1 records不支持继承
2 records能含有variant parts（呵呵，不知翻译成什么能说明白，就是case部分），类不可以
3 records是值类型，可以通过赋值拷贝，类是参考类型，因此不能通过赋值来拷贝。
4 records在win32和.net上允许操作符重载，类仅在.net上支持操作符重载
5 records使用一个缺省的没有参数的构造函数（constructor）自动创建，而类必须明确的创建。在record中用户定义的构造函数必须有一个或多个参数。
6 record类型不能有析构函数（destructors）
7 虚方法（那些指定了virtual、dynamic和message关键字的）不能使用在record类型中
8 record类型在win32开台上不能实现接口，在.net平台上能实现接口

record是用来定义记录类型的..
具体就是比如说你做一个录入&查询学生基本情况的程序，你就可以定义
student[50]:record
name:string;
age:integer;
weight:integer;
height:integer;
end;
然后在主程序里你就可以按 student[12].name:='yyydeyangzi'这样来给它赋值了..读取、打印等操作类似..这就算是一定意义上的面向对象程序设计了...也就是说把student[12]看作一个对象，name、age、weight、height之类的就是这个对象的各种属性...
但以上是按照pascal语法来说的，我对Delphi没有什么研究，但大体上应该是一致的...

本文链接

批量修改选中区域的变量名

2010-07-03T08:25:00Z

2010-07-03T08:25:00Z2010-07-03T08:25:00Z泡面 @ 幸福http://www.cnblogs.com/aipeli/

本文链接

代码折叠

2010-07-03T08:19:00Z

{$REGION ‘xxxxxxxxxxxxxx’}

procedure class1.aaaaa()

begin

end;

procedure class1.bbbbb()

begin

end;

{$ENDREGION}

本文链接

[转]常用公共函数单元

2010-07-03T08:08:00Z

http://blog.csdn.net/hsuchong/archive/2007/03/13/1528248.aspx

本文链接

[转]Delphi程序启动参数的读取

2010-06-29T02:47:00Z

Delphi中有两个专门用于读取命令行参数的变量:
Paramcount-->用于返回命令行参数的个数
Paramstr数组-->用于返回指定的命令行参数
示例代码:
showmessage('命令行参数个数为:'+inttostr(paramcount));
showmessage('第1个命令行参数为:'+paramstr(1));
showmessage('应用程序名称为:'+paramstr(0));

本文链接

在接口中定义属性

2010-06-29T01:38:00Z

unit　Unit1; interface uses 　Windows,　Messages,　SysUtils,　Variants,　Classes,　Graphics,　Controls,　Forms, 　Dialogs,　StdCtrls; type 　TForm1　=　class(TForm) 　　Button1:　TButton; 　　procedure　Button1Click(Sender:　TObject); 　end; 　{此接口声明了一个　Name　属性;　因为接口没有字段,　read/write　都只能从方法} 　IMyInterface　=　interface 　　function　GetName　:　string; 　　procedure　SetName(val　:　string); 　　property　Name　:　string　read　GetName　write　SetName; 　end; 　{类实现的是接口的读写方法,　属性还是属于接口的;　类可以提供一个储存属性的字段} 　TMyClass　=　class(TInterfacedObject,　IMyInterface) 　private 　　FName:　string; 　public 　　function　GetName:　string; 　　procedure　SetName(val:　string); 　end; var 　Form1:　TForm1; implementation {$R　*.dfm} {　TMyClass　} function　TMyClass.GetName:　string; begin 　Result　:=　FName; end; procedure　TMyClass.SetName(val:　string); begin 　FName　:=　val; end; {　TForm1　} procedure　TForm1.Button1Click(Sender:　TObject); var 　c:　TMyClass; 　i:　IMyInterface; begin 　c　:=　TMyClass.Create; 　i　:=　c; 　i.Name　:=　'ABC'; 　ShowMessage(i.Name);　{ABC} 　//没有一个　c.Name　存在,　这个属性只属于接口 end; end.

本文链接

[转]解决Windows Installer 无法打开此修补程序包的问题

2010-06-28T04:02:00Z

症状
当您首次尝试安装 Microsoft Office 程序或运行某个 Office 程序时，可能收到一条错误消息。如果您是通过 Administrator 用户帐户登录计算机的，可能收到下面的错误消息：
安装时发生严重错误
如果您是通过具有管理员权限的标准用户帐户登录计算机的，可能收到下面的错误消息：
无法打开修补程序包。请与应用程序供应商联系，验证这是否是 Windows Installer 的修补程序包。
您可能还会收到以下错误消息：• 无法访问您要使用的功能所在的 CD-ROM 或其他可移动式磁盘。请插入 Office XP product 磁盘并单击“确定”按钮。
注意：在此消息中，Office XP product 是您使用的具体 Office 产品的名称。
• 无法打开修补程序包。请与应用程序供应商联系，验证这是否是 Windows Installer 的修补程序包。
• The installation source for the product in not available.Verify that the source exists and that you can access it.
• This patch package could not be opened.Verify that the patch package exists and that you can access it, or contact the application vendor to verify that this is a valid Windows Installer patch package.
原因
如果注册表中包含来自安装的较低版本 Office 的 Microsoft Windows Installer 信息，可能会发生此问题。
[color=Red]解决方案[/color]
要解决此问题，请运行 Windows Installer 清理实用工具，删除 Windows Installer 注册表设置，然后重新安装 Office。为此，请按照下列步骤操作： 1. 下载、安装、然后运行 Windows Installer 清理实用工具，删除与您的 Office 安装相关的 Windows Installer 注册表设置。可以从 Microsoft 下载中心下载以下文件：
msicuu2.exe (http://download.microsoft.com/download/e/9/d/e9d80355-7ab4-45b8-80e8-983a48d5e1bd/msicuu2.exe)
有关如何下载 Microsoft 支持文件的更多信息，请单击下面的文章编号，以查看 Microsoft 知识库中相应的文章：
119591 (http://support.microsoft.com/kb/119591/) 如何从联机服务获取 Microsoft 支持文件
Microsoft 已对此文件进行了病毒扫描。Microsoft 使用的是该文件发布时可以获得的最新病毒检测软件。该文件存储在安全性得到增强的服务器上，这些服务器可帮助防止对该文件进行未经授权的更改。如果您运行的是 Windows NT 4.0 或 Microsoft Windows 2000，请单击下面的链接，下载并安装 Windows 清理实用工具。
2. 要使用 Windows 清理实用工具，请按下列步骤操作： a. 单击“开始”，指向“程序”，然后单击“Windows 安装清理”。
b. 选择要删除的程序，然后单击“删除”。
c. 单击“确定”，然后单击“退出”。
有关如何下载、安装和使用 Windows Installer 清理实用工具的更多信息，请单击下面的文章编号，以查看 Microsoft 知识库中相应的文章：
290301 (http://support.microsoft.com/kb/290301/) Windows Installer 清理实用工具说明
3. 运行 Office 安装程序，重新安装 Office。
注意：由于 Windows Installer 清理实用工具会删除与 Windows Installer 相关的注册表设置，而不会删除 Office 程序文件，因此，请确保将 Office 安装在它原来所在的文件夹中，以防止硬盘上的文件重复。
【清理软件的下载：http://download.microsoft.com/download/e/9/d/e9d80355-7ab4-45b8-80e8-983a48d5e1bd/msicuu2.exe】

本文链接

[转]Delphi继承、属性、重载

2010-06-27T10:07:00Z

1. 继承

类名称 = class（父类名称）

public

<公共类元素>

private

<私有类元素>

protected

<保护类元素>

published

<可显类元素>

End;

Tobject是其他所有类的最终祖先，因此如果类在声明中没有指定父类，那默认为Tobject

如果有构造方法和析构方法，请放置在公共类型中，析构方法后要放override

在基类中的方法定义后加有virtual形式时，子类定义同名方法加override，此时称之为覆盖。

保留字inherited

n 后跟一个成员名称，表示在封装了方法的类的直接祖先中搜寻成员之外，还可以表示标准方法的调用或对属性、域的引用。

n 反之，只表示对当前定义声明封装的方法在所属类的直接祖先中同名方法的调用

2. 虚拟方法与动态方法

加有关键字virtual 的方法称为虚拟方法，关键字dynamic的方法称为动态方法。两者都可以被覆盖。

3. Reintroduce再引入

用于防止编译器关于隐藏先前的虚拟方法给出警告，

你在写子类时，新声明了一个跟父类中已有的方法同名的方法，这样编译器将会自动
对父类该方法进行隐藏！当父类中的方法为普通静态方法时，无所谓的，你只要在子类中直接声明定义你的同名方法即可，编译器对于这种隐藏不会有什么反应！但是，当父类中该方法为虚拟或动态方法时，你在子类中所声明并定义的同名方法，编译器将会报警说你隐藏了基类中的同名虚拟方法！所以，假如你确定要这么做，而又不想让编译器进行报警的话，就要用到reintroduce，说白了，它的用法就是去镇压编译器的报警的！

4. overload重载方法

（在Reintroduce基础上），该方法重载了继承得到的方法而没有对其隐藏，调用子类中的方法是根据给出的参数来决定哪个方法被激活。

5. 抽象类abstract

只有类中有一个抽象方法，那么该类就是抽象类。

抽象方法的定义：

procedure[function] 方法名（参数表）;virtual;abstract;

说明：抽象方法的前提该方法必需是一个虚拟方法，不同之处在于，抽象方法只是定义，并不进行任何实现，而是由子类实现覆盖的地方进行实现。

6. 属性

1) 说明：

属性是与对象相关的数据的接口，具有访问说明符，用来决定如何读取和修改属性的数据。

2) 定义：

Property 属性名：类型①[Read/数据域/方法/]②[Write/数据域/方法/]

③[Stored/True/False/方法/]④[Default缺省值;]

1. 四部分为可选，如果没有，表明继承父类的属性。

2. 有①无②表明该属性为只读

3. 有②无①表明该属性为只写

4. ③表示窗体设计时设定的属笥值是否存储在DFM文件中

5. ④初始化数据域，没有时缺省值为0

属性与变量的关系;

设置属性，其相当于声明了一个公共的变量。属性是控件对外发部的接口，而变量是控件实际运行时属性存取数据的地方。

获得属性通过定义一个函数得到相应的反回值，写属性通过定义一个过程对其变量进行赋值。格式如下：

Function 读函数名：非简单属性类型

Proceture 写过程名（Value:非简单属性类型）

本文链接

[转]Delphi编程良好惯

2010-06-27T08:00:00Z

=====================================================
个人编程经验
=====================================================
1、没想好别写代码；没写好代码别运行。
2、将字体颜色定义为常量，以后好改。比如：CkdTitleFont,DKDTextFont.
3、做程序前先做框架，尤其是数据模块，主菜单，ActionList，要不你程序大时主窗口很乱.
4、若你的系统依赖前人做的系统，那么做数据库设计时别忽略前人做的系统的数据库结构分析。
5、做需求时别将太多的时间花在界面设计上，因为这时数据库结构可能也不清楚更谈不上什么界面了。
界面、数据模块设计应在做程序前设计，当然需求时做的界面有参考价值。
6、出错处理包括：目录、文件的存在性、表是否空、用户访问数据库是否发生冲突。
7、最好是单独定义一个单元文件来定义常量及系统私有函数，要不可能有出现重复定义现象。

Delphi   4   程序员代码编写标准指南
版权所有   1998   Xavier   Perched和   Steve   Teiseira
一、序言
二、通用源代码格式规则
2.1   缩格
2.2   页边空格
2.3   Begin…End   配对
三、Object   Pascal
3.1   括号
3.2   保留字和关键字
3.3   过程和函数（例程）
        3.3.1   命名/格式化
        3.3.2   形式参数
                3.3.2.1   格式化
                3.3.2.2   命名
                3.3.2.3   参数的排序
                3.3.2.4   常量参数
                3.3.2.5   名称的冲突
3.4   变量
        3.4.1   变量的命名和格式
        3.4.2   局部变量
        3.4.3   全局变量的使用
3.5   类型
        3.5.1   大写约定
                3.5.1.1   浮点指针类型
                3.5.1.2   枚举类型
                3.5.1.3   变数和ole变数类型
        3.5.2   结构类型
                3.5.2.1   数组类型
                3.5.2.2   记录类型
3.6   语句
        3.6.1   if   语句
        3.6.2   case   语句
                3.6.2.1   一般性话题
                3.6.2.2   格式
        3.6.3   while   语句
        3.6.4   for   语句
        3.6.5   repeat   语句
        3.6.6   with     语句
                3.6.6.1   一般话题
                3.6.6.2   格式
3.7   结构异常处理
        3.7.1   一般话题
        3.7.2   try…finally的使用
        3.7.3   try…except的使用
        3.7.4   try…except…else的使用
3.8   类类型
        3.8.1   命名和格式
        3.8.2   域
                3.8.2.1   命名/格式
                3.8.2.2   可视化
        3.8.3   方法
                3.8.3.1   命名/格式
                3.8.3.2   使用静态的方法
                3.8.3.3   使用虚拟/动态的方法
                3.8.3.4   使用抽象的方法
                3.8.3.5   属性存取方法
        3.8.4   属性
                3.8.4.1   命名/格式
                3.8.4.2   使用存取的方法
四、文件
4.1   工程文件
        4.1.1   命名
4.2   窗体文件
        4.2.1   命名
4.3   数据模板文件
        4.3.1   命名
4.4   远端数据模板文件
        4.4.1   命名
4.5   Unit文件
        4.5.1   通用Unit结构
                4.5.1.1   unit的名字
                4.5.1.2   uses子句
                4.5.1.3   interface部分
                4.5.1.4   implementation部分
                4.5.1.5   initialization部分
                4.5.1.6   finalization部分
        4.5.2   窗体单元
                4.5.2.1   命名
        4.5.3   数据模板单元
                4.5.3.1   命名
        4.5.4   一般目的单元
                4.5.4.1   命名
        4.5.5   构件单元
                4.5.5.1   命名
4.6   文件头
五、窗体和数据模板
5.1   窗体
        5.1.1   窗体类型命名标准
        5.1.2   窗体实例命名标准
        5.1.3   自动创建窗体
        5.1.4   模式窗体实例化函数
5.2   数据模板
        5.2.1   数据模板命名标准
        5.2.2   数据模板实例命名标准
六、包
6.1   使用运行包和设计包的比较
6.2   文件命名标准
七、构件
7.1   用户自定义构件
7.2   构件单元
7.3   使用注册单元
7.4   构件实例命名约定
7.5   构件的前缀
7.6   Standard页
7.7   Additional页
7.8   Win32页
7.9   System页
7.10   Internet页
7.11   Data   Access页
7.12   Data   Controls页
7.13   Decision   Cube页
7.14   QReport页
7.15   Dialogs页
7.16   Win3.1页
7.17   Samples页
7.18   ActiveX页
7.19   Midas页
一、序言
本文档详述了在Delphi   4开发者指南下进行编程的代码编写标准。在通常情况下，本文档遵循 "取消 "式格式的指引方针，该方针由Borland国际通过一些例外来使用。在Delphi   4开发者指南中包含本文档的目的在于阐述一种方法，通过该方法，开发小组可以在他们所编写的代码中保持一贯的风格。这样做的目的是使在开发小组中的每一个程序员都可以明白其他程序员的代码。这有助于提高代码编写的可读性和使用的一贯性。
本文档并不意味着包含了所有存在于代码中的标准。但是，它的内容已足够帮你起个好头。你可以自由的增加修改这些标准来满足你的需要。我们不赞成你偏离这些由Borland开发人员所使用的标准太远。我们推荐这么做是因为一旦有新的程序员加入到你的开发小组中，而他们最喜欢和最熟悉的是Borland的标准。象大多数代码标准文档，本文档也会根据需要进行改动。因此，你可以到www.xapware.com/ddg中找到最新的更新版本。本文档不包括用户接口标准。本文档是独立的但也是同样重要的。已经有足够的第三方书籍和Microsoft文档包括了另外一些指导方针，而我们决定并不复制这些信息，但我们会指引你到Microsoft   Developers   Network   和一些资源，在那儿可以找到你所需的信息。
二、通用源代码格式规则
2.1   缩格
缩格是指在每一级有两个空格。不要在源代码中保留tab字符，这是因为tab字符会随着不同用户的不同设置和不同的资源管理工具（打印、文档、版本控制等）而代表不同的宽度。
你可以通过关闭Environment选项对话框中Editor页上的 "Use   tab   character "和 "Optimal   fill "检查框（通过Tools|Environment）来禁止保存tab字符。
2.2   页边空格
页边空格会被设置成80字符宽。通常，源码不会超出这个边界，但这个方针会有一些弹性。不管是否有可能，那些超出到另一行的语句会在一个逗号或其他操作符之后与前面的语句相连。当一个语句被打断相连时，它应比原来的那一行语句缩进两个字符。
2.3   Begin…End   配对
Begin   子句应写在独立的一行。例如，下面第一行是错误的写法而第二行是正确的。
for   I   :=   0   to   10   do   begin     //错误，begin同for在同一行
for   I   :=   0   to   10   do                 //正确，begin出现在独立的一行
begin
这个规则的例外是当begin子句的出现是作为一个else子句的一部分－参考例子：
if   some   statement   then
begin
    …
end
else   begin
    someOtherStatement;
end;
end   语句永远出现在独立的一行。
当begin语句不是一个else子句的一部分时，相应的end语句永远缩进到与begin部分相对应的位置。
三、Object   Pascal
3.1   括号
永远不要在括号与括号之间的字符中间留下空格。下面的例子示范了错误的与正确地使用括号中的空格：
                  CallProc(   Aparameter   );         //错误
                  CallProc(Aparameter);             //正确
永远不要在一个语句中使用不必要的括号。括号只应在源代码中需要的地方使用。以下的例子示范了错误和正确的使用：
if   (I   =   42)   then                                         //错误   －   多余的括号
if   (I   =   42)   or   (J   =   42)   then                 //正确   －   需要括号
3.2   保留字和关键字
Object   Pascal   保留字和关键字永远是全部小写。
3.3   过程和函数（例程）
3.3.1   命名/格式化
例程的名字永远应该以大写的字母开头并且中间错落分明以便于可读性。下面是一个不正确格式的过程名称：
                  procedure   thisisapoorlyformattedroutinename;
下面是一个合适的大小写例程名称的例子：
                  procedure   ThisIsMuchMoreReadableRoutineName;
例程的名称应该同它的内容相符。一个会导致某个行为的例程应以动词开头。例如：
                  procedure   FormatHardDrive;
一个用于设置输入参数的例程应以单词set作为前缀，例如：
                  procedure   SetUserName;
一个用来接收某个值的例程应以单词get作为前缀，例如：
                  procedure   GetUserName   :   string;
3.3.2   形式参数
3.3.2.1   格式化
如果有的话，相同类型的形参应合并在一个语句中：
    procedure   Foo(Param1,   Param2,   Param3   :   Integer;   Param4   :   string);
3.3.2.2   命名
所有形参的名字应是十分符合它们所代表的意义，特别是应该以传送到例程中的标志符的名称为基础。一个好的参数名称应以字符A为前缀   －   例如：
    procedure   SomeProc(AuserName   :   string;   AuserAge   :   integer);
"A "前缀按约定表示该参数的名称是与类类型中的一个属性或域的名称相对应的。
3.3.2.3   参数的排序
下面的形参的顺序重点说明了注册者调用约定调用的好处。
－   最常用的参数应放在第一位，其它的参数应按从左到右的顺序排列。
－   输入参数列表应放在输出参数列表的左边。
－   将通用的参数放在特殊参数的左边，例如：
            procedure   SomeProc(Aplanet,   AContinent,   Acountry,   Astate,   Acity)
－   排序有可能有些例外，比如事件的处理。类型为TObject的Sender参数经常放在第一位。
3.3.2.4   常量参数
当一个参数为记录型、数组类型、ShortString、或接口类型并且在例程中不被改变时，这些参数应做上常量标记。这样做会让编译器更加有效率的产生有关这些不改变的参数的代码。
而例程中另外一些非变参数也可常量来传送。尽管这样做没有产生任何效果和提高效率，这将会给调用例程的使用者提供更多的信息。
3.3.2.5   名称的冲突
当使用拥有两个名称相同的例程的两个单元时，如果你调用该例程时，在uses子句中排在后面的单元中的例程将会被调用。为了解决这种 "在uses子句上的模糊 "冲突，要在调用该例程时写上相关的单元的前缀，例如：
                sysUtile.FindClose(SR);
或
                windows.FindClose(Handle);
3.4   变量
3.4.1   变量的命名和格式
变量的命名应以使用它们的目的相符
循环控制变量应采用一个单独的字符作为名字，比如   I，J，或K，也可以采用更加有意义的名字，比如   UserIndex。
逻辑变量的名字应能充分表达准确的真或假的意思。
3.4.2   局部变量
一个过程中的局部变量应遵循所有其它变量的使用和命名约定。临时变量的取名应合理。
如果必须的话，在一进入例程就应初始化局部变量。局部的AnsiString变量会自动初始化为一个空的字符串。
局部接口和派分接口类型变量将会自动初始化为nil，并且局部变数和ole变数类型变量会自动初始化为Unassigned
3.4.3   全局变量的使用
使用全局变量是不推荐的。但是，在某些时候还是必须使用，而且它们也只应在必须使用的时候才使用。在这种时候，你应努力只在一段上下文范围内使用全局变量。例如，一个全局变量只应在一个单元的implemntation部分内是全局的。如果打算在多个单元类使用全局数据，你应将它们移到一个公共的单元中然后被其它所有单元使用。
全局变量可以在var子句中直接初始化为一个值。记住，所有的全局数据会自动初始化为0,因此不要将全局变量初始化为一个 "空 "值比如   0、nil、 ' '、Unassigned、等等。这样做的一个理由是因为零－初始化的全局数据在exe文件中不会占据任何空间。零－初始化数据被存储在一个虚拟的数据段，它在应用程序启动后被分配在一段内存中。非零－初始化的全局数据在硬盘的exe文件占用空间。
3.5   类型
3.5.1   大写约定
如果类型的名字是保留字，那么它应全部小写。Win32   API类型通常全部大写，并且你必须遵循在Windows.pas或其他API单元中的详细类型名称的约定。对于其他变量名字，地一个字母应为大写，而其他字母应错落有致。下面是一些例子：
            var
                MyString   :   string;                     //保留字
                WindowHandle   :   HWND;                 //Win32   API   类型
                I   :   Integer;                                 //在System单元中引进的类型标识符
3.5.1.1   浮点指针类型
不推荐使用Real类型，因为它的存在只是为了向前兼容早期的Pascal代码。在通常情况下用Double来实现浮点指针的需要。并且，Double对处理器和总线而言是做了最优化处理的，它也是IEEE中定义的标准数据格式。只有当需要的范围超出Double所定义的范围时才使用Extended。Extended是intel定义的类型且在Java中不支持。只有当浮点指针变量的实际字节大小有其意义时才使用Single。（比如当使用另一种语言的DLLs时）。
3.5.1.2   枚举类型
枚举类型的名字需符合使用该类型的目的。该类型的名字需以字符T为前缀，以表明这是一个类型。枚举类型中的标识符列表必须包含两个或三个字符的前缀来对应于该枚举类型的名字   －   例如：
                TsongType   =   (stRock,   stClassical,   stCountry,   stAlternative,   stHeavyMetal,   stRB);
一个枚举类型的实例的名字应与不要前缀的枚举类型（SongType）相同，除非有更好的原因来赋予该变量更特殊的名字，比如：FavoriteSongType1,FavoriteSongType2   等等。
3.5.1.3   变数和ole变数类型
通常不建议使用变数和Ole变数类型。但在只有运行时刻才能知道数据类型的程序中必须使用该类型，这种情形多出现在COM和数据库开发中。Ole变数使用在以COM为基础的编程中例如自动化和ActiveX控制，而变数使用在非COM的编程中，这是因为变数可以十分有效地存储本地Delphi字符串（同一个字符串变量一样），但Ole变数会将所有的字符串转换为Ole字符串（WideChar   字符串）并且并不实例运算   －   它们永远拷贝。
3.5.2   结构类型
3.5.2.1   数组类型
数组类型的名字需符合它们使用的目的。该类型的名字必须加以前缀T。如果须声明该数组类型的指针，那么该指针需加以前缀P而且应立即声明在该数组声明的前面。例如：
                type
                    PCycleArray   =   ^TCycleArray;
                    TCycleArray   =   array[1…100]   of   integer;
在实际应用中，数组的变量实例的名称应是其类型的名字去掉前缀T。
3.5.2.2   记录类型
记录类型的名字应符合使用它们的目的。其类型的声明应加以前缀T。如果要声明该记录类型的指针，就应加以前缀P并且应紧靠在类型声明的前面声明。例如：
                type
                    PEmployee   =   ^TEmployee;
                    TEmployee   =   record
                        EmployeeName   :   string;
                        EmployeeRate   :   Double;
                    end;
3.6   语句
3.6.1   if   语句
在if/then/else语句中最常发生的行为应放在then子句中，而其它发生可能性较小的行为应放在else子句中。
尽量避免使用嵌套的if语句，在这种情形下应用多个if语句来判断各种可能。
不要使用if嵌套超过五级深度。应使代码编写得更加清晰、明了。
不要在if语句中使用不必要的圆括号。
如果在if语句中有多个条件需测试，这些条件应按计算强度由少到多的顺序从左到右排列。这样做能使编译器在编译代码时获得布尔估算逻辑的捷径，从而使你的代码获得最佳的优化。举例来说，如果条件1快过条件2，而条件2快过条件3，那么在if语句中的排列应是：
                  if   条件1   and   条件2   and   条件3   then
3.6.2   case   语句
3.6.2.1   一般性话题
在一个case语句中的各个独立的单元应以数字或字母顺序排列。
每一个case单元的动作行为应保持简单而不应该超过四到五行代码。如果所要执行的动作过于复杂应采用独立的过程或函数。
Case语句中的else子句只有当需要缺省行为或处理错误时才使用。
3.6.2.2   格式
case语句应遵循其它结构的缩格和命名约定。
3.6.3   while   语句
在一个while语句中不建议使用exit过程来跳出循环，尽量仅使用循环条件来跳出循环。
在一个while循环中所用的初始化代码应紧靠在进入while循环前面出现而不要被其它不相关的语句隔开。
任何结束后的处理应在循环之后立即进行。
3.6.4   for   语句
for语句只有当循环次数已知的情况下才能取代while语句使用。
3.6.5   repeat   语句
repeat语句的使用同while语句一样，并且遵循同样的通用方针。
3.6.6   with     语句
3.6.6.1   一般话题
with语句应节省使用，并且带有大量的警告。避免过度使用with语句并且在with语句中小心使用多个对象、记录等等。例如：
                  with   Record1,   Record2   do
这些事情会使程序员感到困惑并难以发现问题所在。
3.6.6.2   格式
with   语句遵循本文档所说明的命名约定和缩格的格式规则。
3.7   结构异常处理
3.7.1   一般话题
异常的处理大量地使用在错误纠正和资源保护方面。这就是说一旦资源被分配，一个try…finally必需加以使用来保证该资源被正确的释放。这种异常的保护也是指在一个单元的initializition/finalization或一个对象的constructor/destructor中进行资源的分配和释放。
3.7.2   try…finally的使用
任何情形下，每一次的分配都应跟随一个try…finally。举例来说，下面的代码会造成可能的错误：
          SomeClass1   :=   TsomeClass.Create;
          SomeClass2   ;=   TsomeClass.Create;
          try
              {   do   some   code   }
          finally
              SomeClass1.Free;
              SomeClass2.Free;
          end;
一个更安全更合适的分配过程应是：
          SomeClass1   :=   TSomeClass.Create;
          try
              SomeClass2   :=   TsomeClass.Create;
              try
                  {   do   some   code   }
              finally
                  SomeClass2.Free;
              end;
          finally
              SomeClass1.Free;
          end;
3.7.3   try…except的使用
只有当在异常被触发而你想执行一些任务时才使用try…except。通常，你没有必要为了只是简单地在屏幕上显示一个错误信息而使用try…except语句，因为这会被Application对象自动执行。如果你想在except子句中执行完一些任务之后调用缺省的异常处理，使用raise来重新触发异常到下一个句柄。
3.7.4   try…except…else的使用
try…except中的else子句不建议使用，因为它会打断所有的异常包括那些你没有准备的异常。
3.8   类类型
3.8.1   命名和格式
类类型的名称应符合使用它们的目的。类型名字应加以前缀T以表明这是一个类型的定义   －   例如：
type
    Tcustomer   =   class(TObject)
类型的实例通常是没有前缀T的类型的名字   －   例如：
var
    Customer   :Tcustomer;
注意：查阅 "构件类型的命名标准 "来获得更多有关构件命名的信息。
3.8.2   域
3.8.2.1   命名/格式
类的域名遵循与变量标识符同样的约定除了它们应以F为前缀，来表明这是一个域的名称。
3.8.2.2   可视化
所有的域都必需是私有的。想在类的范围之外存取域得通过属性来使用。
3.8.3   方法
3.8.3.1   命名/格式
方法的命名应遵循本文档中有关过程和函数的约定叙述。
3.8.3.2   使用静态的方法
如果使用一个静态的方法，那么该方法就不能被该类的后代类所继承。
3.8.3.3   使用虚拟/动态的方法
如果你打算该类的方法能被后代的类所继承就得使用虚拟的方法。只有在该方法有多个继承时（直接的或间接的）才使用动态的方法。例如，一个类类型包含一个可继承的方法，而100个后代类要继承这种方法，那么这个方法就会动态地产生为100个后代类使用的内存。
3.8.3.4   使用抽象的方法
如果在一个类中使用抽象的方法，该类就不能被创建。只有在那些永远不会被创建的类中使用抽象的方法。
3.8.3.5   属性存取方法
所有存取类的方法都只能出现在类的private或protected部分。属性存取方法的命名应遵循过程和函数的约定规则。读取存取方法（方法读取器）必需以单词Get为前缀。写入存取方法（方法写入器）必需以单词Set为前缀。方法写入器的参数的名字应为Value，并且它的类型应是它所操作的属性的类型。例如：
TSomeClass   =   class(TObject)
private
      FsomeField   :   Integer;
protected
      function   GetSomeField   :   Integer;
      procedure   SetSomeField(Value   :   Integer);
public
      property   SomeField   :   Integer   read   GetSomeField   write   SetSomeField;
end;
3.8.4   属性
3.8.4.1   命名/格式
属性如果是表示为一个私有域的存取器的话，那么它的名字应是它们所操作的域的名字除去解释符F。
属性的名字应是名词，不是动词。属性表示的是数据，而方法表示的是行为。
数组类型的名称应为复数。一般情况下属性的名称应为单数。
3.8.4.2   使用存取的方法
尽管没有要求，但还是建议尽量少地为一个表示私有域的属性而使用写入存取方法。
四、文件
4.1   工程文件
4.1.1   命名
工程文件应取个描述性的名字。例如，Delphi   4开发者指南错误管理器   的工程名字是：DDGBugs.dpr。一个有关系统信息的程序的名字就应象   SysInfo.dpr。
4.2   窗体文件
4.2.1   命名
一个窗体文件的取名应可以描述使用该窗体的目的，并加以后缀Frm。例如，一个 "关于 "的窗体的文件名应是AboutFrm.dpr。主窗体的文件名应是MainFrm.dpr。
4.3   数据模板文件
4.3.1   命名
数据模板的取名应能表示使用该数据模板的目的，它的名称应加以两个字符的后缀DM。例如，自定义数据模板的文件名字应为CustomersDM.dfm。
4.4   远端数据模板文件
4.4.1   命名
远端数据模板的取名应能表示使用该远端数据模板的目的，它的名称应加以三个字符的后缀RDM。例如，自定义远端数据模板的文件名字应为CustomersRDM.dfm。
4.5   Unit文件
4.5.1   通用Unit结构
4.5.1.1   unit的名字
Unit文件应取一个可描述性的名字。例如，包含应用程序主窗体的单元应叫做MainFrm.pas。
4.5.1.2   uses子句
在interface部分的uses子句应包含在interface部分中的代码所需要的单元。去掉那些Delphi可以自动加入到程序中的单元。
在implementation部分的uses子句应只包含在implementation部分中的代码所需要的单元的名字。去掉不必要的单元。
4.5.1.3   interface部分
interface部分应包含只那些其它单元所需要存取类型的定义、变量、过程/函数的预定义等等。否则，就应放在implementation部分定义。
4.5.1.4   implementation部分
implementation部分应包含那些只在本单元中私用的类型定义、变量、过程/函数定义等等。
4.5.1.5   initialization部分
不要在initialization   部分放入耗时长的代码，这将使程序的第一个界面出现
得比较缓慢。
4.5.1.6   finalization部分
在这里要保证释放你在Initialization部分所分配的任何资源。
4.5.2   窗体单元
4.5.2.1   命名
一个窗体的单元文件应拥有与它所对应的窗体文件同样的名称。例如， "关于 "窗体的单元名称应为   AboutFrm.pas，而主窗体的单元名称应为MainFrm.pas。
4.5.3   数据模板单元
4.5.3.1   命名
一个数据模板的单元文件应拥有与它所对应的数据模板文件同样的名称。例如，一个自定义数据模板单元的名称应为CustomersDM.pas。
4.5.4   一般目的单元
4.5.4.1   命名
一般目的单元的取名应符合使用该单元的目的。例如，一个实用程序单元取名为BugUtilities.pas。一个包含全局变量的单元取名为CustomerGlobals.pas。
注意，该单元的名字不能与它的工程中所使用的所有包中的单元的名字相同。不赞成使用一般的或通用的单元名字。
4.5.5   构件单元
4.5.5.1   命名
构件单元应放在独立的目录，以将它们同定义构件组或构件集合的单元区分开来。它们要永远同工程在不同的目录。单元名字应同它们的内容相符。
注意：查阅 "用户定义的构件 "部分来获得更多有关构件命名标准的信息。
4.6   文件头
建议在所有源文件、工程文件、单元等等中使用信息化文件头。一个良好的文件头应包含以下信息：
｛
版权…   著作的年、月、日…
}
五、窗体和数据模板
5.1   窗体
5.1.1   窗体类型命名标准
窗体类型的取名应能表达使用该窗体的目的。类型定义应加以前缀T。前缀后面跟随着描述性的名字。最后，应加以Form后缀来描述名字。例如，一个 "关于 "的窗体的类型的名字应为：
                TAboutFrom   =   class(TForm);
主窗体的定义为：
                TMainForm   =   class(TForm);
一个用户接入窗体的名字应象：
                TCustomerEntryForm   =   class(TForm);
5.1.2   窗体实例命名标准
窗体实例应是没有带前缀T的相应类的名字。例如，对应于前面窗体类型而言，其实例的名字应为：
          类型名称                                       实例名称
      TAboutForm                                 AboutForm
      TMainForm                                   MainForm
      TCustomerEntryForm             CustomerEntryForm
5.1.3   自动创建窗体
只有主窗体可以是自动创建的除非有其它更好的理由不这样做。所有其它的窗体必需从工程选项对话框中的自动创建列表中移走。查阅以下部分来获得更多的信息。
5.1.4   模式窗体实例化函数
所有的窗体单元都应包含一个窗体实例化函数，该函数用来创建、设置、模式地显示窗体，并释放窗体。该函数应返回窗体的模式结果。该函数要传递的参数应遵循本文档指定的 "参数传递 "标准。通过这种方式封装的函数性有助于代码的再利用和维护。
该窗体的变量要从单元中移走，并再窗体实例的函数中进行本地式地定义。注意，这就意味着该窗体必需从工程/选项对话框中的自动创建列表中剔除。参考本文档后面的 "自动创建窗体 "。
例如，下面的单元展示了再GetUserData窗体中的一个函数。
    unit   UserDataFrm;
    interface
    uses
windows,   Messages,   SysUtils,   Classes,   Graphics,   Controls,   Forms,
Dialogs,   StdCtrls;
    type
        TUserDataForm   =   class(TForm)
            edtUserName   :   TEdit;
            edtUserID   :   TEdit;
        private
            {   Private   declarations   }
        public
            {   Public   declarations   }
        end;
    function   GetUserData(var   aUserName   ：   String;   var   aUserID   :   Integer)   :
        Word;
    implementation
    {$R   *.DFM   }
    function   GetUserData(var   aUserName   :   String;   var   aUserID   :   Integer)   :
        word;
    var
        UserDataForm   :   TuserDataForm;
    begin
        UserDataForm   :=   TuserDataForm.Create(Application);
        try
            UserDataForm.Caption   :=   'Getting   User   Data ';
            Result   :=   UserDataForm.ShowModal;
            if   (Result   =   mrOK)   then
            begin
                aUserName   :=   UserDataForm.edtUserName.Text;
                aUserID   :=   StrToInt(UserDataForm.edtUserID.Text);
            end;
        finally
            UserDataForm.Free;
        end;
    end;
    end.
5.2   数据模板
5.2.1   数据模板命名标准
数据模板的取名要符合使用该数据模板的目的。类型的定义应加以前缀T，后面紧接着描述性的名字，最后要加以后缀单词 "DataModule "。例如，一个自定义的数据模板有时候应该象：
                        TCustomerDataModule   =   class(TDataModule)
一个命令式的数据模板的名字应象：
                        TOrdersDataModule   =   class(TDataModule)
5.2.2   数据模板实例命名标准
数据模板实例的名称应是对应不带前缀T的类型的名称。例如，对于前面的窗体类型而言，其实例的名称应为：
                      类型名称                                             实例名称
                    TCustomerDataModule             CustomerDataModule
                    TOrdersDataModule                 OrdersDataModule
六、包
6.1   使用运行包和设计包的比较
运行时刻的包应只包含其它构件包所要求的单元或构件。另外，包含属性/构件编辑器和其它只为设计的代码应放入到设计时刻包中。注册单元应放在设计包中。
6.2   文件命名标准
包的名称应依照下面的例子：
"iiilibvv.pkg "   －   设计时刻包
"iiistdvv.pkg "   －   运行时刻包
字符 "iii "表示一个3字符标识前缀。这个前缀用来表明公司、个人或其它有标识意义的实体。
字符 "vv "表示为该包想要对应Delphi某个版本的包的版本号。
注意，包的名字中包含 "lib "或 "std "的意思是表明这是一个设计时刻包还是一个运行时刻包。
如果既是设计时刻包又是运行时刻包，该文件的命名是同上面一样的，例如，为Delphi   4开发者指南做的包的名称应为：
DdgLib40.pkg   -   设计时刻包
DdgStd40.pkg   -   运行时刻包
七、构件
7.1   用户自定义构件
在标准构件中命名出来的构件的名称同在 "类类型 "部分定义中的一样定义成一个类类型，不同的是它们有一个3字符的指示前缀，这个前缀可以表示公司、个人或其它实体。例如，一个为Delphi   4开发者指南编写的时钟构件的名称定义为：
            TddgClock   =   class(TComponent)
注意，那三个前缀字符是小写的。
7.2   构件单元
构件单元应只包含一个主要的构件，一个主要的构件是指出现在构件栏中的构件。主要构件的辅助构件/对象应放入到同一个单元中。
7.3   使用注册单元
构件的注册过程应从构件本身的单元中剔除，并放入到一个独立的单元中。这个注册单元可以用来注册任何构件、属性编辑器、构件编辑器、专家器等。
构件的注册只应在设计时刻包中进行，注册单元应包含在设计时刻包中而不应放在运行时刻包中。
推荐使用的注册单元的名称是：
XxxReg.pas
上面的3个前缀字符 "Xxx "用来表示一个公司、个人或任何其它的实体。例如，在Delphi   4   开发者指南中的注册单元的名称应为   DdgReg.pas。
7.4   构件实例命名约定
所有的构件都应取个描述性的名称。由Delphi创建的缺省名的构件不会被遗弃。在设计构件类型时应设计一个小写的前缀。使用前缀而不使用后缀的原因是在搜寻时，在对象检查器和代码探索器中搜寻构件的名字比搜寻构件的类型更容易实现。
7.5   构件的前缀
以下构件的前缀可以用来设计Delphi   4中的标准构件。请在此列表中加入第三方构件的前缀。
7.6   Standard页
前缀             构件
mm                 TMainMenu
pm                 TPopupMenu
mmi               TMainMenuItem
pmi               TPopupMenuItem
前缀             构件
lbl               TLabel
edt               TEdit
mem               TMemo
btn               TButton
cb                 TCheckBox
rb                 TRadioBox
lb                 TListBox
cb                 TComboBox
scb               TScrollBar
gb                 TGroupBox
rg                 TRadioGroup
pnl               TPanel
cl                 TCommandList
7.7   Additional页
bbtn             TBitBtn
sb                 TSpeedButton
me                 TMaskEdit
sg                 TStringGrid
dg                 TDrawGrid
img               TImage
shp               TShape
bvl               TBevel
sbx               TScrollBox
clb               TCheckListbox
spl               TSplitter
stx               TStaticText
cht               TChart
7.8   Win32页
tbc               TTabControl
pgc               TPageControl
il                 TImageList
re                 TRichEdit
thr               TTrackBar
prb               TProgressBar
ud                 TUpDown
hk                 THotKey
ani               TAnimate
dtp               TDateTimePicker
tv                 TTreeView
lv                 TListView
hdr               THeaderControl
前缀             构件
stb               TStatusBar
tlb               TToolBar
clb               TCoolBar
7.9   System页
tm                 TTimer
pb                 TPaintBox
mp                 TMediaPlayer
olec             TOleContainer
ddcc             TDDEClientItem
ddci             TDDEClientItem
ddsc             TDDEServerConv
ddsi             TDDEServerItem
7.10   Internet页
csk               TClientSocket
ssk               TServerSocket
wbd               TWebDispatcher
pp                 TPageProducer
tp                 TQueryTableProducer
dstp             TDataSetTableProducer
nmdt             TNMDayTime
nec               TNMEcho
nf                 TNMFinger
nftp             TNMFtp
nhttp           TNMHttp
nMsg             TNMMsg
nmsg             TNMMSGServ
nntp             TNMNNTP
npop             TNMPop3
nuup             TNMUUProcessor
smtp             TNMSMTP
nst               TNMStrm
nsts             TNMStrmServ
ntm               TNMTime
nudp             TNMUdp
psk               TPowerSock
ngs               TNMGeneralServer
html             THtml
url               TNMUrl
sml               TSimpleMail
7.11   Data   Access页
前缀             构件
ds                 TDataSource
tbl               TTable
qry               TQuery
sp                 TStoredProc
db                 TDataBase
ssn               TSession
bm                 TBatchMove
usql             TUpdateSQL
7.12   Data   Controls页
dbg               TDBGrid
dbn               TDBNavigator
dbt               TDBText
dbe               TDBEdit
dbm               TDBMemo
dbi               TDBImage
dblb             TDBListBox
dbcb             TDBComboBox
dbch             TDBCheckBox
dbrg             TDBRadioGroup
dbll             TDBLookupListBox
dblc             TDBLookupComboBox
dbre             TDBRichEdit
dbcg             TDBCtrlGrid
dbch             TDBChart
7.13   Decision   Cube页
dcb               TDecisionCube
dcq               TDecisionQuery
dcs               TDecisionSource
dcp               TDecisionPivot
dcg               TDecisionGrid
dcgr             TDecisionGraph
7.14   QReport页
qr                 TQuickReport
qrsd             TQRSubDetail
qrb               TQRBand
qrcb             TQRChildBand
qrg               TQRGroup
qrl               TQRLabel
前缀             构件
qrt               TQRText
qre               TQRExpr
qrs               TQRSysData
qrm               TQRMemo
qrrt             TQRRichText
qrdr             TQRDBRichText
qrsh             TQRShape
qri               TQRImage
qrdi             TQRDBMImage
qrcr             TQRCompositeReport
qrp               TQRPreview
qrch             TQRChart
7.15   Dialogs页
对话框构件是由构件封装的真正的窗体，因此，它们应遵循窗体的命名约定。类型已由构件的名称定义。它的实例的名称是Delphi自动生成的类型实例名字去掉数字后缀。举例如下：
            类型                                         实例名字
        TOpenDialog                           OpenDialog
        TSaveDialog                           SaveDialog
        TOpenPictureDialog           OpenPictureDialog
        TSavePictureDialog           SavePictureDialog
        TFontDialog                           FontDialog
        TColorDialog                         ColorDialog
        TPrintSetupDialog             PrintSetupDialog
        TFindDialog                           FindDialog
        TReplaceDialog                   ReplaceDialog
7.16   Win3.1页
dbll             TDBLookupList
dblc             TDBLookupCombo
ts                 TTabSet
ol                 TOutline
tnb               TTabbedNoteBook
nb                 TNoteBook
hdr               THeader
flb               TFileListBox
dlb               TDirectoryListBox
dcb               TDriveComboBox
fcb               TFliterComboBox
7.17   Samples页
gg                 TGauge
前缀             构件
cg                 TColorGrid
spb               TSpinEdit
spe               TSpinEdit
dol               TDirectoryOutline
cal               TCalendar
ibea             TIBEventAlerter
7.18   ActiveX页
cfx               TChartFX
vsp               TVSSpell
f1b               TF1Book
vtc               TVTChart
grp               TGraph
7.19   Midas页
prv               TProvider
cds               TClientDataSet
qcds             TQueryClientDataSet
dcom             TDCOMConnection
olee             TOleEnterpriseConnection
sck               TSocketConnection
rms               TRemoteServer
mid               TMidasConnection

本文链接