Delphi-基础（常量、集合、数组[动态数组、多维数组]）

一、常量

　　1、常量定义:一开始定义好的值，以后在程序的运行过程中不允许改变

1 const
2   pi : double = 3.141592;   //定义为常量
3   {常量的定义方式，可以不进行类型的声明，编译器会根据具体值决定常量的的类型}
4   pi2 = 3.1415;

 

2、常量使用　　

　　枚举：常量集
　　type
　　枚举名=(标识符1，标识符2，标识符3，......)

 1 type
 2   {正常情况下，枚举类型的索引是从0开始}
 3   ecolors = (red,green,blue);
 4   eweek = (sun=7,mon=1,tue=2,wed=3,thu=4,fri=5,sat=6);
 5 var
 6   color : ecolors;
 7   week : eweek;
 8 
 9 begin
10   color := ecolors.red;
11   week := eweek.sun;
12   writeln(ord(color),',',ord(week));
13   redln;
14 end.

 

二、子界

　　使用：为了防治出现越界
　　注意事项:
　　1、子界要求上界和下界必须是有序的数据类型 整数、字符、枚举
　　2、子界的上界大于或者等于下界

　　格式：type 子界

 1 {定义格式}
 2 type
 3   {枚举}
 4   ecolors = (red,green,blue);
 5   {子界}
 6   tsubboundnumber = 1..10;
 7   tsubboundchar = 'a'..'z';
 8 
 9 
10 begin
11   writeln(low(tsubboundnumber)); //下界
12   writeln(high(tsubboundchar));  //上界
13   redln;
14 end.

 

打印出闰年还是平年，每个月的天数和所属季节

 1 {打印出闰年还是平年，每个月的天数和所属季节}
 2 type
 3   {子界}
 4   tsubboundmonths = 1..12;
 5   {枚举}
 6   eseason = (spring,summer,autumn,winter);
 7 
 8 var
 9   season : eseason;
10   month : tsubboundmonths;
11   user_year:integer;
12   is_leap_year:boolean;
13   user_month : integer;
14 
15 procedure subbound();
16 begin
17   writeln('请输入一个年份：');
18   redln(user_year);
19   {默认为闰年}
20   is_leap_year := true;
21   while is_leap_year do
22   begin
23     if (user_year mod 4) = 0 then begin
24     if not((user_year mod 100) = 0) then begin
25       writeln('闰年',user_year);
26       is_leap_year := false;
27     end;
28   end;
29   if (user_year mod 400) = 0 then begin
30     writeln('闰年',user_year);
31     is_leap_year := false;
32   end
33   else begin
34     is_leap_year := false;
35     writeln('平年',user_year)
36 
37   end;
38   end;
39 
40 end;
41 procedure months();
42 begin
43   {季节}
44 writeln('请输入一个月份：');
45 redln(user_month);
46 begin
47   if (user_month >= low(tsubboundmonths)) and (user_month <= high(tsubboundmonths)) then
48     if (user_month >= 1) and (user_month <= 3) then begin
49       writeln('当前季节为春季');
50       case user_month of
51         1 : begin
52               writeln('31天');
53             end;
54         2 : begin
55               if is_leap_year then  begin
56               writeln('29天');
57               end else begin
58                 writeln('28天');
59               end;
60             end;
61         3 : begin
62               writeln('31天');
63             end;
64       end;
65     end;
66 
67 end;
68 end;
69 
70 begin
71 //  writeln(low(tsubboundnumber)); //下界
72 //  writeln(high(tsubboundchar));  //上界
73 
74   subbound();
75   months();
76   redln;
77 end.

 

三、集合

集合是由具有某些共同特征的元素结构的一个整体。在pascal中，一个集合是由一有序类型的一组数据元素组成，者一有序类型成为该集合的而基本类型。

 

集合定义：

1 type
2 <类型名称>=set of<基类型>;

 

声明集合的变量（可使用集合类型的名称来声明，也直接利用集合类型的本身来声明）

1 var
2 vset1:set1;
3 vset2:set of byte;

 

注意：
1、一个集合类型的所有成员必须是同一有序类型且最多包含256个成员。
2、集合类型具有唯一性，即同一集合类型中不允许包含相同的成员。
3、集合类型成员具有无序性，其中的成员没有序数。无法向枚举型一样用序数标识集合成员。
4、集合类型的值域由basetype 的值域决定。

 

集合定义方式

1 {定义方式}
2 type  {type主要作用是让用户可以自定义类型}
3   tmyset = set of char;
4   tmyset1 = set of 'a'..'z';
5 var
6   tmyset2 : set of  'a'..'z';

 

集合示例

 1 uses
 2   system.sysutils,system.typinfo;
 3 
 4 type
 5   {定义一个枚举}
 6   tcolors = (red,green,blue);
 7 type
 8   tsetcolors = set of tcolors;
 9 var
10   sc : tsetcolors;
11   indexs : integer;
12 procedure set_test1;
13 begin
14   for indexs := ord(low(tcolors)) to ord(high(tcolors)) do begin
15 
16     writeln(getenumname(typeinfo(tcolors),indexs)) //显示枚举内信息
17   end;
18 
19 end;
20 begin
21   {遍历集合元素：无序的}
22   set_test1();
23   readln;
24 end.

 

四、数组

数组：按照一定编号存放了一堆类型相同数据的容器

定义
array[indextype1, ..., indextypen] of basetype;

注意事项
1、数组在使用之前必须要声明长度（下标、元素总数）

 1 type   {定义变量}
 2   myarray = array[0..4] of char;
 3 var   {变量声明}
 4   namearray : myarray;
 5   indexs : integer;
 6 
 7 {静态数组元素遍历}
 8 procedure myproc;
 9 begin
10   namearray[0] := 'a';
11   namearray[1] := 'b';
12   namearray[2] := 'c';
13   namearray[3] := 'd';
14   for indexs := low(namearray) to high(namearray) do begin
15       writeln(namearray[indexs]);  //屏幕输出
16   end;
17 
18 end;
19 
20 type
21   tmyflexiblearray = array[0..4] of char;
22 var
23   tmyarray : tmyflexiblearray;
24   elem : char;  //与数组类型保持一致
25 procedure myproc1;
26 begin
27   tmyarray[0] := 'a';
28   tmyarray[1] := 'b';
29   tmyarray[2] := 'c';
30   tmyarray[3] := 'd';
31   for elem in tmyarray do   //取数组里面的元素
32   begin
33     writeln(elem); //输出数组中的具体元素
34   end;
35   writeln(length(tmyarray)); //取数组最大可用数（可用元素）
36 
37 end;
38 
39 begin
40 //  myproc();
41   myproc1();
42   readln;
43 end.

 

五、动态数组

 1 {动态数组}
 2 type
 3   stringarray = array of string;
 4 var
 5   narray : stringarray;
 6   namearray1 : stringarray;
 7   indexs1 : integer;
 8   elem1 : string;
 9 
10 procedure dynamic_myproc1;
11 begin
12   setlength(narray,20); //设置长度，并未创建元素
13 
14   namearray1 := stringarray.create('xiaoqian','xiaoming');  //创建数组，设置长度
15   namearray1 := ['xiaoming','xiaoyang','xioaogang'];  ////创建数组，设置长度
16 //  writeln(length(narray),',',low(narray));
17   writeln(length(namearray1),',',low(namearray1));
18   {遍历1数组 for to }
19   for indexs1 := low(namearray1) to high(namearray1) do  begin
20     writeln(namearray1[indexs1]);
21   end;
22   {遍历2数组 for in}
23   for elem1 in namearray1 do
24   begin
25     writeln(elem1);
26   end;
27 end;
28 
29 begin
30 
31   dynamic_myproc1();
32   readln;
33 end.

 1 {动态数组2}
 2 type
 3   stringarray1 = array of string;
 4 var
 5   namearray2 : stringarray1;
 6   addressarray : stringarray1;
 7   dataarray : stringarray1;
 8   dataarray1: stringarray1;
 9   name : string;
10   indexs2 :integer;
11   namearray3 : stringarray1;
12 
13 procedure dynamic_myproc2;
14 begin
15   namearray2 := ['北京','南京','天津'];
16   addressarray := ['林志玲','萧蔷'];
17   {concat 连接连个数组}
18   dataarray := concat(namearray2,addressarray);
19 
20   {拷贝数组,high(dataarray1),copy含头不含尾}
21   for name in dataarray do begin
22 //    writeln(name)     //北京 南京 天津 林志玲 萧蔷
23   end;
24 
25   dataarray1 := copy(dataarray,low(dataarray),high(dataarray));
26   for indexs2 := low(dataarray1) to length(dataarray1) do begin
27 //    writeln(dataarray1[indexs2])     //北京 南京 天津 林志玲 萧蔷
28   end;
29 
30   {insert插入}
31    namearray3 := ['11','22'];   //等待插入的数据
32   insert(namearray3,dataarray,10);
33   for name in dataarray do begin
34 //    writeln(name)     //北京 南京 天津 林志玲 萧蔷  11 22
35   end;
36 
37   {delete删除}
38    delete(dataarray,length(dataarray)-2,length(dataarray));
39   for name in dataarray do begin
40       writeln(name)     //北京 南京 天津 林志玲 萧蔷
41   end;
42 
43 end;
44 
45 begin
46 
47   dynamic_myproc2();
48   readln;
49 end.

 

六、多维数组

 1 {多维数组：1、静态多维数组 2、动态多维数组}
 2 type
 3 {声明一个动态的二位数组}
 4   tstringdynamicarray2 = array of array of string;
 5 {声明一个静态二维数组}
 6   tstringstaticarray3 = array[0..3] of array[0..2] of string;
 7 var
 8   tdynamicnamearray : tstringdynamicarray2;
 9   tstaticarray : tstringstaticarray3;
10   i,j : integer;
11 {初始化动态二位数组}
12 procedure tstringdynamic_array2;
13 begin
14   tdynamicnamearray := [['张三','李四','王五'],['成都','重庆','西安']];
15   {遍历二维数组}
16   for i := low(tdynamicnamearray) to high(tdynamicnamearray) do begin
17     for j := low(tdynamicnamearray[i]) to high(tdynamicnamearray[i]) do begin
18       writeln(tdynamicnamearray[i][j]);
19     end;
20 
21   end;
22 
23   writeln(tdynamicnamearray[0][1]);
24 end;
25 
26 {初始化静态二位数组}
27 procedure tstringstatic_array3;
28 begin
29   tstaticarray[0][0] := '开心麻花';
30    for i := low(tstaticarray) to high(tstaticarray) do begin
31     for j := low(tstaticarray[i]) to high(tstaticarray[i]) do begin
32       writeln(tstaticarray[i][j]);
33     end;
34 
35   end;
36 end;
37 
38 begin
39 //  tstringdynamic_array2();
40   tstringstatic_array3();
41   readln;
42 end.

 

七、基础练习

  1 type
  2   {定义一个学生的信息的记录类型}
  3   tstudent = record
  4     id: string; //学号
  5     name: string; //姓名
  6   end;
  7 
  8 {数组存储信息}
  9 tstudentlist = array of tstudent;
 10 var
 11   student: tstudent;
 12   studentlist : tstudentlist;
 13 
 14 {查看菜单}
 15 procedure showmemo();
 16 begin
 17   writeln('');
 18   writeln('*****memo*****');
 19   writeln('1、增加');
 20   writeln('2、查询');
 21   writeln('3、修改');
 22   writeln('4、删除');
 23   writeln('');
 24 end;
 25 
 26 {添加用户信息}
 27 procedure addstudent();
 28 var
 29   username : string;
 30   arraylength : integer;
 31   uuid:tguid;   //生成一个唯一标识
 32 begin
 33   writeln('您选择了增加功能，请输入学生姓名');
 34   readln(username);
 35   student.name := username;
 36   arraylength := length(studentlist);
 37   createguid(uuid);
 38   student.id := guidtostring(uuid);
 39 //  writeln(guidtostring(uuid));   //输出uuid 信息
 40 
 41   insert(student,studentlist,arraylength-1); //添加
 42   if (length(studentlist)>arraylength) then begin
 43     writeln('添加成功！');   //输出uuid 信息
 44   end else begin
 45     writeln('添加失败');
 46   end;
 47 
 48 end;
 49 
 50 {查询用户信息}
 51 procedure selectstudent();
 52 var
 53   student1 : tstudent;
 54 begin
 55   writeln('您选择了查询功能，查询结果如下：');
 56   for student1 in studentlist do begin
 57     with student1 do begin
 58       writeln('姓名:',name,#$09,'编号:',id);
 59     end;
 60   end;
 61 end;
 62 
 63 {删除用户信息}
 64  procedure deletestudent();
 65 var
 66 student2 : tstudent;
 67 delusername : string;
 68 istrue : string;
 69 indexs : integer;
 70 arraylength : integer;
 71 begin
 72   writeln('您选择了删除功能，请输出删除名字');
 73   readln(delusername);
 74   indexs := 0;
 75   {获取删除之前的数据总和}
 76   arraylength := length(studentlist);
 77   for student2 in studentlist do begin
 78     with student2 do begin
 79       if (delusername=name) then begin
 80         {删除操作需要谨慎，需要用户二次确认}
 81         writeln('您确认删除',name,',',id,'信息吗？y/n');
 82         readln(istrue);
 83         if (istrue = 'y') then begin
 84           delete(studentlist,indexs,1);
 85         {删除后,比对元素总数，判断是否成功}
 86           if (length(studentlist) > arraylength) then begin
 87             writeln('删除成功');
 88           end
 89           else begin
 90             writeln('删除!');
 91           end;
 92         end;
 93         exit;
 94       end;
 95     end;
 96     inc(indexs);  //每次增加1
 97   end;
 98 end;
 99 
100 {更新/修改}
101 procedure updateuser();
102 var
103   uname : string;
104   i : integer;
105   isexist : boolean;
106 begin
107   isexist := false; {默认不存在这条信息}
108   writeln('您选择了修改功能,请输出需要的用户姓名：');
109   readln(uname);
110   {遍历数组，查询需要修改的数据}
111   for i := low(studentlist) to high(studentlist) do begin
112     with studentlist[i] do begin
113       if (uname = name) then begin
114         writeln('请输出新的名字');
115         readln(uname); //重新给uanme 赋值
116         name := uname;
117         isexist := true;
118         break;
119       end;
120     end;
121   end;
122   if (isexist = false) then begin
123   writeln('此信息不存在');
124   end;
125 end;
126 
127 {用户选择功能}
128 procedure userchoose();
129 var
130   userchooseindex: integer;
131 begin
132   writeln('请输入你的功能选项：');
133   {获取用户输入编号}
134   readln(userchooseindex);
135   {判断用户输入编号}
136   case userchooseindex of
137     1:
138       begin
139         addstudent();
140       end;
141     2:
142       begin
143         selectstudent();
144       end;
145     3:
146       begin
147         updateuser();
148       end;
149     4:
150       begin
151         deletestudent();
152       end;
153 
154   else
155     begin
156       writeln('请输出正确的功能编号');
157     end;
158   end;
159 end;
160 
161 begin
162 {初始化学生信息列表}
163 studentlist := [];
164 {无限循环}
165   while true do
166   begin
167     showmemo();
168     userchoose();
169   end;
170   readln;
171 end.