003_Delphi的通配符语句结构和常量变量类型

//通配符使用

//*^13 :查找所有//及回车前的内容.

[{\{]*[}\}] 可以搜索{}里面的内容.

[（\(]*[）\)]这样就是搜索()里面的内容

1、Delphi注释方法：

1,//代码注释 2,(*代码注释*) 3｛代码注释｝

2、IF。。。Then语句

3、只有一条语句结束的情况下才允许加分号

if (Edit1.Text='') or (edit2.Text='') then//如果只有在一顶可以if  Edit1.Text=’’ then
begin

showmessage('输入信息不全');

edit1.SetFocus;

end//此处不可以写成 end; 加分号的情况下是语句结束。因为后面有Else。。。


else

begin
…

End

4、变量的声明

var
  Value: Integer;
  IsCorrect: Boolean;
  A, B: Char;
在Delphi 中，当你声明全程变量时，你可以赋给它一个初值。例如，你可以这样写：
var
  Value: Integer = 10;
  Correct: Boolean = True;这种初始化方法只能用于全程变量，不能用于过程或方法的变量。

5、常量（变量用var声明，常量const声明,中间不用“：”，不需类型）

1需要赋一个初值。

2中间不用‘：’，因为不需要类型

编译器会根据所赋初值自动选用合适的数据类型。

例如：

const
  Thousand = 1000;
  Pi = 3.14;
  AuthorName = 'Marco Cantù';
Delphi 根据常量的值来决定它的数据类型。

6.日期类型（var）

var  //声明
StartTime: TDateTime;
procedure TFormTimeNow.FormCreate(Sender: TObject);
begin
  StartTime := Now;
  ListBox1.Items.Add (TimeToStr (StartTime));//
  ListBox1.Items.Add (DateToStr (StartTime));
  ListBox1.Items.Add ('Press button for elapsed time');
end;

运行结果：

03：08：41 PM

3/15/99

Press button for elapsed time

FormatDateTime('yyyy"-"MM"-"dd',now);

得到 2012-01-07

7、子界类型

子界类型定义了某种类型的取值范围（因此定名subrange）。你可定义整数类型的子界类型，如取值从1到10或从100到1000，或者定义字符类型的子界类型，如下所示：

type

Ten = 1..10;

或者直接

var

Ten:1..10;

定义子界类型时，你不需要指定基类的名字，而只需提供该类型的两个常数。所用基类必须是有序类型，定义结果将是另一种有序类型。

如定义一个子界变量，那么赋给该变量的值必须是子界定义范围内的值。下面代码是正确的：

var
  UppLetter: UpperCase;
begin
  UppLetter := 'F';

8、枚举类型

枚举类型又是一种自定义有序类型。在枚举类型中,你列出所有该类型可能取的值，而不是指定现有类型的范围。换句话说，枚举类型是个可取值的序列。见下例：

type
  Colors = (Red, Yellow, Green, Cyan, Blue, Violet);
  Suit = (Club, Diamond, Heart, Spade);
也可以这样简化
Var 
Colors：(Red, Yellow, Green, Cyan, Blue, Violet);
var
Colors: (Red, Yellow, Green, Cyan, Blue, Violet);

ShowMessage(IntToStr(ord(Yellow)));得到整数1

注意的是，千万不可以这样写：Colors = (‘Red’，’Yellow’)；也千万不可以有相同的名称出现。

序列中每个值都对应一个序号，序号从0开始计数。使用Ord 函数，即可得到一个枚举类型值的序号。例如，Ord (Diamond) 返回值1。

9、数组类型

数组类型定义了一组指定类型的元素序列，在方括号中填入下标值就可访问数组中的元素。定义数组时，方括号也用来指定可能的下标值。例如，下面的代码中定义了一个有24个整数的数组：

type
  DayTemperatures = array [1..24] of Integer;
//简写方式：
var
DayTemperatures:array[1..24]of Integer;

在数组定义时，你需要在方括号中填入一个子界类型的值，或者用两个有序类型的常量定义一个新的子界类型，子界类型指定了数组的有效索引。由于子界类型指定了数组下标值的上界和下界，那么下标就不必象C、C++、JAVA和其他语言那样必须从零开始。

使用上述数组定义方法，定义一个DayTemperatures 类型的变量如下：

type
  DayTemperatures = array [1..24] of Integer;

var  
  DayTemp1: DayTemperatures;
  
procedure AssignTemp;  
begin  
  DayTemp1 [1] := 54;
  DayTemp1 [2] := 52;
  ...
  DayTemp1 [24] := 66;
  DayTemp1 [25] := 67; // 超出范围了。报错的。

数组可以是多维的，如下例：

type
  MonthTemps = array [1..24, 1..31] of Integer;
  YearTemps = array [1..24, 1..31, Jan..Dec] of Integer;

上例的声明把索引的次序前后调换了一下，但仍允许变量之间整块赋值。例如：把一月份的温度值赋给二月份：

var
  ThisYear: YearTemps;
begin
  ...
  ThisYear[Feb] := ThisYear[Jan];

使用数组时，你总要用标准函数Low和 High来检测它的边界，Low和 High返回下标的下界和上界。强烈建议使用Low和 High操作数组，特别是在循环中，因为这样能使代码与数组范围无关，如果你改变数组下标的范围声明，Low和 High代码不会受影响；否则，如果代码中有一个数组下标循环体，那么当数组大小改变时你就不得不更新循环体的代码。Low和 High将使你的代码更易于维护、更稳定。

实例：

 type
    nul1=array[0..9]of Integer;//定义数组
var
nul123:nul1;

下面是简写的方法，直接

// var
nul123:array[0..9]of Integer;
for i:=Low(nul123) to High(nul123) do
  begin
     nul123[i]:=i*10;
  lst1.Items.Add(IntToStr(nul123[i]) ) ;
  end;

10、记录类型（Type。record。。end结尾）

记录类型用于定义不同类型数据项的固定集合。记录中每个元素，或者说域，有它自己的类型。记录类型定义中列出了所有域，每个域对应一个域名，通过域名可以访问它。

下面简单列举了记录类型的定义、类型变量的声明以及这类变量的使用：

type
  Date = record
    Year: Integer;
    Month: Byte;
    Day: Byte;
  end;
  
var
  BirthDay: Date;
  
begin
  BirthDay.Year := 1997;
  BirthDay.Month := 2;
  BirthDay.Day := 14;

11、指针类型

指针是存放指定类型（或未定义类型）变量内存地址的变量，因此指针间接引用一个值。定义指针不需用特定的关键字，而用一个特殊字符，这个特殊字符是脱字符号(^)，见下例：

type
  PointerToInt = ^Integer;
//或者直接这样
var
  P: ^Integer;

一旦你定义了指针变量，你就可以用@ 符号把另一个相同类型变量的地址赋给它。见下例：

var
  P: ^Integer;// ^加类型 ：定义整型的指针变量
  X: Integer;//整型
begin
  P := @X;//@+变量名，表示将变量的地址赋给它。
  // 改变值的两种方法
  X := 10;//X的值是多少，就等于P^的值，因为内在地址是相等的。
  P^ := 20;  //变量名+^ 表示内存所存储的实际内容

如果定义了一个指针P，那么P表示指针所指向的内存地址，而P^表示内存所存储的实际内容。因此，在上面的代码中， P^ 与X相等。

除了表示已分配内存的地址外，指针还能通过New 例程在堆中动态分配内存，不过当你不需要这个指针时，你也必须调用Dispose 例程释放你动态分配的内存。

var
  P: ^Integer;
begin
  // initialization
  New (P);//分配内存
  // operations
  P^ := 20;//内存的值.
  ShowMessage (IntToStr (P^));
  // termination
  Dispose (P);//释放内存
end;

如果指针没有值，你可以把nil 赋给它。这样，你可以通过检查指针是否为nil 判断指针当前是否引用一个值。这经常会用到，因为访问一个空指针的值会引起一个访问冲突错误，也就是大家知道的“一般保护错”（GPF）。见下例：

procedure TFormGPF.BtnSafeClick(Sender: TObject);
var
  P: ^Integer;
  X: Integer;
begin
  P := @X;//将地址赋给对方.
  X := 100;
  if P <> nil then
    ShowMessage (IntToStr (P^));
end;

Delphi 还定义了一个Pointer 数据类型，它表示无类型的指针（就象C语言中的void* ）。如果你使用无类型指针，你应该用GetMem 例程，而不是New例程，因为GetMem 例程能用于内存分配大小不确定的情况。

注意：虽然在Delphi中不常使用指针，但是你经常会用一个极为相似的结构--引用（references）。每个对象实例实际上是一个隐含的指针，或说是对其实际数据的引用，利用引用，你能象用其他数据类型一样使用对象变量。

12.、Case语句

有序类型(有序类型, 包括整型, 枚举类型, 字符型,绝对不允许是String类型)。Case语句最后可以带一个else 语句，当没有一个标签与选择器的值一致时，执行else语句。下面是两个简单的例子：

case Number of// Case 变量 Of…End
  1: Text := 'One';
  2: Text := 'Two';
  3: Text := 'Three';
end;

case MyChar of
  '+' : Text := 'Plus sign';
  '-' : Text := 'Minus sign';
  '*', '/': Text := 'Multiplication or division';
  '0'..'9': Text := 'Number';
  'a'..'z': Text := 'Lowercase character';
  'A'..'Z': Text := 'Uppercase character';
else
  Text := 'Unknown character';
end;

13、For循环

Pascal 中的for循环严格地建立在计数器基础上，循环每执行一次，计数器不是增加一个值就是减小一个值。下面是一个for语句的简例，用来将前十个数加起来：

var
  K, I: Integer;
begin
  K := 0;
  for I := 1 to 10 do
K := K + I;

for i:=10 downto 1 do//例：这里就变成了  10 to 1

14、while语句和repeat语句

while-do 循环语句和 repeat-until 语句的不同点在于repeat 循环语句的代码至少要执行一次。从下面的简例很容易理解这一点：

while (I <= 100) and (J <= 100) do
begin
  // use I and J to compute something...
  I := I + 1;
  J := J + 1;
end;

repeat
  // use I and J to compute something...
  I := I + 1;
  J := J + 1;
until (I > 100) or (J > 100);

从上可见即使 I 或 J 的初始值大于100，repeat-until循环中的代码也仍会执行一次。

15、For和While的例子

procedure TForm1.BtnForClick(Sender: TObject);
var
  I: Integer;
begin
  ListBox1.Items.Clear;
  for I := 1 to 20 do
    Listbox1.Items.Add ('String ' + IntToStr (I));
end;

第二个button的事件代码稍微复杂点。本例中让while 循环基于一个随机增长的计数器。为实现它，我调用了Randomize 过程, 用它来重置随机数发生器，还调用了Random 函数, 其取值范围为100, 即函数返回0至99之间的随机数，随机数序列控制while 循环的执行次数。

procedure TForm1.BtnWhileClick(Sender: TObject);
var
  I: Integer;
begin
  ListBox1.Items.Clear;
  Randomize;
  I := 0;
  while I < 1000 do
  begin
    I := I + Random (100);
    Listbox1.Items.Add ('Random Number: ' + IntToStr (I));
  end;
end;

16、With 语句

With语句是一种用于简化代码的语句。如你要访问一个记录类型变量（或一个对象），用With语句就不必每次重复变量的名字。例如对于以下的记录类型代码：

type
  Date = record
    Year: Integer;
    Month: Byte;
    Day: Byte;
  end;

var
  BirthDay: Date;

begin
  BirthDay.Year := 1997;
  BirthDay.Month := 2;
  BirthDay.Day := 14;
可以用with语句改进后半部分代码，如下：
begin
  with BirthDay do
  begin
    Year := 1995;
    Month := 2;
    Day := 14;
  end;

在Delphi程序中，这种方法能用于访问控件和类变量。现在通过with语句访问列表框的条目，我们重写上面循环例子的最后部分：

procedure TForm1.WhileButtonClick(Sender: TObject);
var
  I: Integer;
begin
  with ListBox1.Items do
  begin
    Clear; // shortcut
    Randomize;
    I := 0;
    while I < 1000 do
    begin
      I := I + Random (100);
      // shortcut:
      Add ('Random Number: ' + IntToStr (I));
    end;
  end;
end;

当你使用控件或类时，with语句通常能简化你的代码，尤其对嵌套域。例如，你要改变窗体画笔的宽度和颜色，你可以写代码如下：

Form1.Canvas.Pen.Width := 2;
Form1.Canvas.Pen.Color := clRed;

但如果用With语句代码会更简单：

with Form1.Canvas.Pen do
begin
  Width := 2;
  Color := clRed;
end;

17、过程与函数（就是方法，他们两个不可以同名）

过程与函数的区别：函数能返回计算结果，即有一个返回值，而过程没有

procedure Hello;
begin
  ShowMessage ('我是过程 ，我没有返回值');
end;

function Double (Value: Integer) : Integer;
begin
  Double := Value * 2;//此为函数，用函数名返回值
end;

// or, as an alternative
function Double2 (Value: Integer) : Integer;
begin
  Result := Value * 2;//这里用到Result返回，这也是通用的方法。
end;

调用过程：

begin
  Hello;
end;

//调用函数：
  X := Double (StrToInt (Edit1.Text));
  Y := Double (X);

17.1引用类型参数（用关键字var表示）

下面是利用引用传递参数的例子，引用参数用var关键字标示：

procedure TForm3.DoubleTheValue(var Value,v1,v2: Integer);
begin
 Value:=v1+v2;
end;
procedure TForm3.Button2Click(Sender: TObject);
var s,a,b:Integer;
begin
a:=2;b:=3;s:=1;//其中a,b,s必须是变量,如果直接DoubleTheValue(s,1,2);这就出错了.因为成常量了.
DoubleTheValue(s,a,b);
end;

17.2过程类型

Object Pascal 的另一个独特功能是可定义过程类型。过程类型属于语言的高级功能，Delphi 程序员不会经常用到它。因为后面章节要讨论相关的内容（尤其是“方法指针” Delphi用得特别多），这里不妨先了解一下。如果你是初学者，可以先跳过这部分，当学到一定程度后再回过头阅读这部分。

Pascal 中的过程类型与C语言中的函数指针相似。过程类型的声明只需要参数列表；如果是函数，再加个返回值。例如声明一个过程类型，该类型带一个通过引用传递的整型参数：

type
  IntProc = procedure (var Num: Integer);
这个过程类型与任何参数完全相同的例程兼容（或用C语言行话来说，具有相同的函数特征）。下面是一个兼容例程：
procedure DoubleTheValue (var Value: Integer);
begin
  Value := Value * 2;
end;

注意：在16位Delphi中，如果要将例程用作过程类型的实际值，必须用far指令声明该例程。

过程类型能用于两种不同的目的：声明过程类型的变量；或者把过程类型（也就是函数指针）作为参数传递给另一例程。利用上面给定的类型和过程声明，你可以写出下面的代码：

var
  IP: IntProc;
  X: Integer;
begin
  IP := DoubleTheValue;
  X := 5;
  IP (X);
end;
这段代码与下列代码等效：
var
  X: Integer;
begin
  X := 5;
  DoubleTheValue (X);
end;

上面第一段代码明显要复杂一些，那么我们为什么要用它呢？因为在某些情况下，调用什么样的函数需要在实际中决定，此时程序类型就很有用。这里不可能建立一个复杂的例子来说明这个问题，不过可以探究一下简单点的例子，该例名为ProcType。该例比前面所举的例子都复杂，更接近实际应用。

如图6.3所示，新建一个工程，在上面放两个radio按钮和一个push按钮。例中有两个过程，一个过程使参数的值加倍，与前面的DoubleTheValue过程相似；另一个过程使参数的值变成三倍，因此命名为TripleTheValue

procedure TripleTheValue (var Value: Integer);
begin
  Value := Value * 3;
  ShowMessage ('Value tripled: ' + IntToStr (Value));
end;

两个过程都有结果显示，让我们知道他们已被调用。这是一个简单的程序调试技巧，你可以用它来检测某一代码段是否或何时被执行，而不用在代码中加断点。

当用户按Apply 按钮，程序会根据radio按钮状态选择执行的过程。实际上，当窗体中有两个radio按钮时，你只能选择一个，因此你只需要在Apply 按钮的OnClick 事件中添加代码检测radio按钮的值，就能实现程序要求。不过为了演示过程类型的使用，我舍近求远选择了麻烦但有趣的方法：只要用户选中其中一个radio按钮，按钮对应的过程就会存入过程变量：

procedure TForm1.DoubleRadioButtonClick(Sender: TObject);
begin
  IP := DoubleTheValue;
end;
//当用户按Apply 按钮，程序就执行过程变量保存的过程：
procedure TForm1.ApplyButtonClick(Sender: TObject);
begin
  IP (X);
end;

为了使三个不同的函数能访问IP和 X变量，需要使变量在整个窗体单元中可见，因此不能声明为局部变量（在一个方法中声明）。一个解决办法是，把这些变量放在窗体声明中：

type
  TForm1 = class(TForm)
    ...
  private
    { Private declarations }
    IP: IntProc;
    X: Integer;
  end;

17.3开放数组参数（数组参数不定）

与C语言不同，Pascal 函数及过程的参数个数是预定的。如果参数个数预先没有确定，则需要通过开放数组来实现参数传递。

一个开放数组参数就是一个固定类型开放数组的元素。也就是说，参数类型已定义，但是数组中的元素个数是未知数。见下例：

function Sum (const A: array of Integer): Integer;
var
  I: Integer;
begin
  Result := 0;//初始化临时值
  for I := Low(A) to High(A) do
    Result := Result + A[I];//返回结果
end;

上面通过High(A)获取数组的大小，注意其中函数返回值 Result的应用， Result用来存储临时值。你可通过一个整数表达式组成的数组来调用该函数：

X := Sum ([10, Y, 27*I]);

给定一个整型数组，数组大小任意，你可以直接把它传递给带开放数组参数的例程，此外你也可以通过Slice 函数，只传递数组的一部分元素（传递元素个数由Slice 函数的第二个参数指定）。下面是传递整个数组参数的例子：

var
  List: array [1..10] of Integer;
  X, I: Integer;
begin
  // initialize the array
  for I := Low (List) to High (List) do
    List [I] := I * 2;
  // call
  X := Sum (List);
//如果你只传递数组的一部分，可使用Slice 函数，如下：
X := Sum (Slice (List, 5));

//结果：Sun(Slice(List,5))=>30

posted @ 2016-03-06 19:08 VignyJames 阅读(316) 评论(0) 收藏举报

刷新页面返回顶部

VignyJames

骄傲在败坏以先，狂心在跌倒之前

003_Delphi的通配符语句结构和常量变量类型

公告