delphi基本语法

//delphi中exit,abort,break,continue 的区别

exit: 退出函数体
abort: 遇到异常,安静处理,就是不显示不提示
break: 退出当前循环体,包括for ,while, repeat等循环体
continue: 结束循环内的本次处理,继续从循环体的开始位置继续执行

Exit 是跳出当前代码块，也就是当前函数，跳出后是要继续向下执行的（若是有后续代码）。

Abort 是从 EAbort 过来的，能够激发 exception，其实质就是 Abort = RaiseException()，是一个不出现对话框的异常。因此 Abort 的行为和异常是同样的，其代码执行顺序也是follow异常的流程。
例如：
try
(1) //执行了
abort;
(2) //不执行
exception
(3) //执行了
end;

用 Abort 可以执行 exception 里边的代码，可是若是用 Exit，就直接离开，无论 exception。

例如：
procedure p1;
begin
p2;
p3;
end;
procedure p2;
begin
abort; //exit;
end;
procedure p3;
begin
//showmessage()..
end;

若是用 Abort，则执行不到 P3，若是用 Exit 就可以执行到 P3

******************************************************************************

在Delphi过程、函数中传递参数几个修饰符为Const、Var、Out。另外一种不加修饰符的为默认按值传递参数。
1、默认方式以值方式传递参数
procedure TForm1.ProcNormal(Value: string);
begin
OrigNum:=Value+' Me';
lblReturn.Caption:=OrigNum;//OrigNum为'Hello Me'
lblOrig.Caption:=Value;//Value为'Hello'
end;

调用：
OrigNum:='Hello';
ProcNormal(OrigNum);

2、以Const方式传递参数，这个参数在调用过程当中不能改变，而且这种方式会被编译器优化，通常建议尽量地使用这种方式。
procedure TForm1.ProcConst(const Value: string);
begin
OrigNum:=Value+' Me';
lblReturn.Caption:=OrigNum;//为'Hello Me‘
lblOrig.Caption:=Value;//为'Hello Me'
end;

3、按引用方式传递参数
procedure TForm1.ProcRef(var value: string);
begin
OrigNum:=Value+' Me';
lblReturn.Caption:=OrigNum;//为'Hello Me‘
lblOrig.Caption:=Value;//为'Hello Me'
end;

4、按Out方式传递参数，这个方式传递参数时，参数能够不被初始化，即便有值也被忽视，它通常用于输出,它能够实如今一个过程当中返回多个值,咱们一般在分布式对象模型，如COM中使用它。
procedure TForm1.ProcOut(out Value: string);
begin
OrigNum:=Value+' Me';
lblReturn.Caption:=OrigNum;//为'Me'
lblOrig.Caption:=Value;//为'Me'
end;

5、无类型参数，这是一种较为特殊的方法，参数的类型不肯定，只能用Const、Var、Out修饰，不能用于值方式传递参数，具体使用示例以下：
procedure TForm1.ProcUntype(const Value);
begin
OrigNum:=string(Value)+' Me';
lblReturn.Caption:=OrigNum;//为'Hello Me'
lblOrig.Caption:=string(Value);//为'Hello Me'
end;

6、默认参数，即若是此参数在调用时未提供时，将使用默认值。
procedure TForm1.ProcDefault(const Value, constDefaultValue:string=' 123');
begin
OrigNum:=Value+' Me'+DefaultValue;
lblReturn.Caption:=OrigNum;//为'Hello Me 123'
lblOrig.Caption:=Value;// 为'Hello Me 123'
end;

7、开放数组参数，即参数数组的元素个数不肯定。
procedure TForm1.ProcArray(const Value: array of string);
var
i:Integer;
begin
for i:=Low(Value) to High(Value) do
OrigNum:=OrigNum+Value[i];//调用后为'Hello abc dbd'
lblReturn.Caption:=OrigNum;
end;

调用：

OrigNum:='Hello';
ProcArray([' abc ',' dbd']);

8、无类型开放数组参数，即类型及元素个数皆不肯定。在WIN32平台中，这个参数的类型实际为array ofTVarRec,其使用示例以下:
procedure TForm1.ProcArrayConst(const Value: array of const);
var
i:Integer;
begin
for i:=Low(Value) to High(Value) do
with Value[i] do
case VType of
vtAnsiString: OrigNum:= OrigNum+String(VAnsiString);
vtInteger: OrigNum:=OrigNum+IntToStr(VInteger);
vtBoolean: OrigNum := OrigNum + BoolToStr(VBoolean);
vtChar: OrigNum := OrigNum + VChar;
vtExtended: OrigNum := OrigNum + FloatToStr(VExtended^);
vtString: OrigNum := OrigNum + VString^;
vtPChar: OrigNum := OrigNum + VPChar;
vtObject: OrigNum := OrigNum + VObject.ClassName;
vtClass: OrigNum := OrigNum + VClass.ClassName;
vtCurrency: OrigNum := OrigNum + CurrToStr(VCurrency^);
vtVariant: OrigNum := OrigNum + string(VVariant^);
vtInt64: OrigNum := OrigNum + IntToStr(VInt64^);
end;
lblReturn.Caption:=OrigNum;//调用后为'Hello abc 3'
end;

调用：

OrigNum:='Hello';
ProcArrayConst([' abc ',3]);

以上就是常见几种传递参数的方式。

//另外一篇文章关于delphi参数传递的//

delphi参数传递

参数传递

  声明/实现一个过程使用的参数称为形式参数（简称形参），调用过程时传入的参数称为实际参数（简称实参）。

{ Info是形参}

procedure ShowInfo(Info: String);

begin

 ShowMessage(Info);

end;

var

 S: String;

begin

 S := 'lxpbuaa';

 {S是实参}

 ShowInfo(S);

end;

参数传递分两种：按值（by val）和引用（by ref）。这两种方式的本质区别是：

按值传递时，形参和实参是两个变量，它们开始时的值是相同的，即实参的数据被拷贝一份传递给了形参。因此此时，形参的改变不会影响到实参。

引用传递时，形参和实参是同一个变量，能够将它们之一看作是另外一个的别名。 因此此时，形参改变时，实参跟着改变。

默认状况下，参数是按值传递的，传递的是数据拷贝；若是加了var前缀，则成了引用传递。

咱们看以下例子：

procedure TForm1.ByVal(I: Integer);   {按值传递I}

begin

 ShowMessage(IntToStr(Integer(@I)));   

 {取得形参所在地址。你会发现它和实参地址是不一样的，由于此时实参和形参是不一样的两个变量}

 I := I + 1;

end;

procedure TForm1.ByRef(var I: Integer); {引用传递I}

begin

 ShowMessage(IntToStr(Integer(@I)));   

 {取得形参所在地址。你会发现它和实参地址是相同的，由于此时实参和形参是同一个变量}

 I := I + 1;

end;

procedure TForm1.Button1Click(Sender: TObject);

var

 I: Integer;

begin

 I := 1;

 ShowMessage(IntToStr(Integer(@I)));     {取得实参所在地址}

 ByVal(I);  { I =1}

 Showmessage(i); {i:=1;实参没有变}

 ByRef(I);  { I =2}

 showmessage(i); {i:=2,实参改变了}

end;

按值传递的参数能够指定默认值，好比上面的ByVal能够是这样：

procedure ByVal(I: Integer = 0);

调用它时能够省掉有默认值的参数：ByVal。带默认值的参数必须位于参数列表的最后，如：

procedure ByVal(I: Integer = 0; B: Boolean);

是不行的，应该改成：

procedure ByVal(B: Boolean; I: Integer = 0);

由于默认值必须是一个常数表达式，因此dynamic-array、procedural、class、class-reference和 interface等参数只能指定nil默认值；而record、variant、file和static-array等类型的参数则根本不能指定默认 值。

若是按值传递一个指针类型的参数，状况会变得复杂而又颇有意思。此时，实际传递的是什么呢？是实际数据的拷贝吗？不，是指针的拷贝，也就是说形参和实参是 两个指针，不过这两个指针指向了相同地址。因此这时候，形参和实参能够共享它们指向地址中的数据，但若是改变了形参的指针指向，实参的指针指向不能跟着改 变。那么总结一下，就是：按值传递指针参数时，实参和形参能够共享指针指向地址中的数据，可是不能共享指针自己的指向。而引用传递时，由于实参和形参是同 一个变量，所以实现彻底共享。看下面的例子：

procedure TForm1.ByVal(Obj: TObject);

begin

 Obj := Button1;   

 {改变形参指针指向，实参的指针指向不会跟着改变，由于它们是两个变量。若是仅仅是改变Obj的属性而不改变指向，则实参的属性会跟着改变}

end;

procedure TForm1.ByRef(var Obj: TObject);

begin

 Obj := Button1;     

 {改变形参指针指向，实参的指针指向跟着改变，由于它们是同一个变量}

end;

procedure TForm1.Button1Click(Sender: TObject);

var

 Obj: TObject;

begin

 Obj := Self;       

 {Self即Form1，因此此时实参Obj的类名（ClassName）是"TForm1"}

 ByVal(Obj);           {按值传递指针变量Obj}

 ShowMessage(Obj.ClassName);   {显示类名"TForm1"}

 ByRef(Obj);            {引用传递指针变量Obj}

 ShowMessage(Obj.ClassName);   {显示类名"TButton1"}

end;

上面讲了这么多，最根本的仍是一句话：按值传递时，形参和实参是两个变量；引用传递时，形参和实参是同一个变量。抓住这句话，就等于抓住了一切。(ps:关键总结):

相信你还看到过以下格式的参数声明：

function CompareStr(const S1, S2: string): Integer;

function TryStrToInt(const S: string; out Value: Integer): Boolean;

其中使用了const和out关键字。若是你没有看到过这样的声明，也没关系，它们是真实存在的。

const声明的参数是按值传递的，并且形参不能被改变。

out声明的参数是引用传递的，主要用于定义输出参数，也就是说不须要输入值（即实参不须要初始化），实参传递给形参的值被忽略。

若是用const修饰指针参数，那么只能经过形参修改指针地址里的数据而不能修改指针自己的指向。例如对于一个const对象参数，能够修改其属性，可是不能将它指向其余对象。例如：

procedure ShowInfo(const Form: TForm);

begin

 {如下一句不能经过，编译器提示：[Error] Unit1.pas(28): Left side  cannot be assigned to}

 {Form := Form1;}

 {可是经过其属性或者方法修改隶属于Form的数据}

 Form.Caption := 'lxpbuaa';

 ShowMessage(Form.Caption);

end;

在本小节的最后，还不得不说起一种很特殊的参数类型：无类型参数（Untyped parameters）。

声明时没有指定数据类型的参数称为无类型参数。所以，从语法上讲，无类型参数能够接收任何类型的数据。

无类型参数必须加const、out或var前缀；无类型参数不能指定默认值。

如如下一些Delphi定义的过程都使用了无类型参数：

procedure SetLength(var S; NewLength: Integer);    {参数S}

procedure Move(const Source;var Dest;Count:Integer);  {参数Source、Dest}

procedure TStream.WriteBuffer(const Buffer; Count: Longint);{参数Buffer}

所谓无类型参数能够接收任何类型的值，只是从语法角度而言的。或者说，理论上咱们能够实现一个可使用任何类型变量做为参数的过程，可是实际上没有必要，也不可能作到。

打个比方说，咱们想造一辆能够装载任何物体的汽车。由于是“任何物体”，因此物体多是任何形状，因而这辆车必须没有车篷，除了在几个车轮上铺一个足够大 （足够大就已是个大问题了）的平板外，不能再有任何东西。这时候，这个平板就能够看作是无类型的，由于它上面能够坐人、摆一张桌子，也能够赶一些动物上 去站着或者躺着。尽管它能够承载不少种类的东西，可是也是有限制的，好比不能放一座山、也没法容纳1万头猪。因此无类型参数的类型每每是有必定限制的。比 如SetLength的参数S只能是字符串、动态数组等。

这种限制通常是在过程的实现中完成的，在运行时检查参数值的实际类型。对于与开发环境关系紧密的参数，限制也能够构筑在编译器里。

使用无类型参数的缘由是没法在声明时使用一个统一的类型来描述运行时可能的类型，如SetLength的参数S能够是字符串和动态数组，而并无一个统一 的类型来表明字符串和动态数组类型，因此干脆声明为无类型。而将类型限制放到别的地方实现（如编译器）。例如SetLength的限制规则是写在编译器中 的，它只能做用于长字符串或者动态数组。你企图完成下面的功能时：

var

 I: Integer;

begin

 SetLength(I, 10);

end;

编译器编译时将给出错误信息：[Error] Unit1.pas(35): Incompatible types。致使编译中断。

小结

本小节的内容比较重要，重点是理解参数按值传递和引用传递的本质：按值传递时，形参和实参是两个变量；引用传递时，形参和实参是同一个变量。

声明指令

声明一个过程，可使用register、pascal、cdecl、stdcall和safecall指令来指定参数传递顺序和参数内存管理方式，从而影响过程的运做。如：

function MyFunction(X, Y: Integer): Integer; cdecl;

这五个指令具备不一样含义，如表3-1所示。

表3-1  五个指令的不一样含义

 

 指令   参数存放位置    参数传递顺序  参数内存管理     适用地点

 register  CPU寄存器    从左到右    被调用者  默认.published属性存取                                  方法 必须使用

 pascal     栈      从左到右    被调用者   向后兼容，再也不使用

 cdecl      栈      从右到左    调用者    调用C/C++共享库

 stdcall     栈      从右到左    被调用者   API调用，如回调函数

 safecall     栈      从右到左    被调用者   API调用，如回调函数。双

在一些源代码（包括Delphi自带的VCL源代码）中，你还可能看到near、far、export以及inline、assemble等指令，它们是 为了和16位Windows系统或者早期Pascal/Delphi兼容，在目前的Delphi版本中，已经不具备任何意义，因此在新的开发中不要再使 用。